STM32 RT-Thread 系统分析（4）-线程管理之线程调度器

最新推荐文章于 2024-07-24 20:09:33 发布
最新推荐文章于 2024-07-24 20:09:33 发布
阅读量2.6k 收藏 12
点赞数 1
分类专栏： RT-thread 学习 文章标签： 嵌入式 stm32 物联网
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44746581/article/details/109055194
版权

线程管理之线程调度器

前言

基本信息

名称描述说明
RT-Thread Studio 软件版本版本: 1.1.3
RT-Thread 系统版本4.0.2
STM32CubeIDE 软件版本1.4.0
STM32芯片型号STM32F013VG

前言说明

前面的讲解都是线程的基础知识，下面以线程调度器为中心进行线程管理的分析。

线程调度器启动前执行的相关流程

系统启动的最后一步就是启动线程调度器。放到最后启动调度器是因为要把前面需要使用的线程初始化之后才可以进行线程调度（切换）和执行。下面是系统的启动流程（rtthread_startup函数），下面会对这个流程中的关键点进行分析：
在这里插入图片描述

说明：

  1. RT-thread系统的启动是从entry函数开始进入rtthread_startup函数。
  2. 这个启动的流程基本上固定，用户可以将自己线程的初始化代码放到main线程初始化的逻辑中。要在板级初始化之后，线程调度器启动之前完成用户线程初始化。

线程调度器

在 RT-Thread 中，线程是实现任务的载体，它是 RT-Thread 中最基本的调度单位，它描述了一个任务执行的运行环境，也描述了这个任务所处的优先等级，重要的任务可设置相对较高的优先级，非重要的任务可以设置较低的优先级，不同的任务还可以设置相同的优先级，轮流运行。
当线程运行时，它会认为自己是以独占 CPU 的方式在运行，线程执行时的运行环境称为上下文，具体来说就是各个变量和数据，包括所有的寄存器变量、堆栈、内存信息等。而线程调度器的作用就是实现这些线程之间的逻辑控制，是非常重要的一个模块。

线程调度器初始化和启动

调度器初始化-rt_system_scheduler_init函数

void rt_system_scheduler_init(void)
{
RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("start scheduler: max priority 0x%02x\n",RT_THREAD_PRIORITY_MAX));
    /*初始化线程优先级链表，默认下一个节点和上一个节点均指向自身地址*/
    for (offset = 0; offset < RT_THREAD_PRIORITY_MAX; offset ++)
    {
        rt_list_init(&rt_thread_priority_table[offset]);
    }
    /*初始化就绪优先级组  initialize ready priority group */
    rt_thread_ready_priority_group = 0;
    /*初始化僵尸队列（资源未回收、处于关闭状态的线程队列） 默认下一个节点和上一个节点均指向自身地址initialize thread defunct */
    rt_list_init(&rt_thread_defunct);
}

说明：
在调度器初始化中，对线程就绪链表、就绪优先级组号、关闭线程链表进行了初始化（其中有多核的宏定义部分暂不分析）。

启动线程调度器-rt_system_scheduler_start函数

下面是rt_system_scheduler_start函数的代码：

/**
 * @ingroup SystemInit
 * This function will startup scheduler. It will select one thread
 * 此函数将启动调度程序。它将选择一个线程
 * 使用最高优先级，然后切换到它。with the highest priority level, then switch to it.
 */
void rt_system_scheduler_start(void)
{
    register struct rt_thread *to_thread;
    rt_ubase_t highest_ready_priority;
    /*获取当前最高优先级的线程*/
    to_thread = _get_highest_priority_thread(&highest_ready_priority);

#ifdef RT_USING_SMP
    to_thread->oncpu = rt_hw_cpu_id();
#else
    rt_current_thread = to_thread; /*将当前运行的线程设置为获取到的最高优先级线程*/
#endif /*RT_USING_SMP*/
    rt_schedule_remove_thread(to_thread);/*将当前线程从线程链表删除*/
    to_thread->stat = RT_THREAD_RUNNING;/*修改当前线程运行状态，设置为正在运行状态*/
    /* switch to new thread */
#ifdef RT_USING_SMP
    rt_hw_context_switch_to((rt_ubase_t)&to_thread->sp, to_thread);
#else
    rt_hw_context_switch_to((rt_ubase_t)&to_thread->sp);//切换到当前设置的线程开始运行
#endif /*RT_USING_SMP*/
    /* never come back */
}

根据上面的代码，线程调度器的启动步骤是：

  1. 获取到当前最高优先级线程
  2. 将当前线程从线程就绪链表删除
  3. 修改当前线程运行状态，设置为正在运行状态
  4. 切换到当前设置的线程开始运行

如果要理解上述步骤的用意，还是要完整的了解线程调度的流程。

_get_highest_priority_thread函数获取当前最高优先级线程的控制块

下面是 _get_highest_priority_thread函数的代码：

static struct rt_thread* _get_highest_priority_thread(rt_ubase_t *highest_prio)
{
    register struct rt_thread *highest_priority_thread;
    register rt_ubase_t highest_ready_priority;

#if RT_THREAD_PRIORITY_MAX > 32
    register rt_ubase_t number;

    number = __rt_ffs(rt_thread_ready_priority_group) - 1;
    highest_ready_priority = (number << 3) + __rt_ffs(rt_thread_ready_table[number]) - 1;
#else//获取当前最高就绪的优先级组编号 
    highest_ready_priority = __rt_ffs(rt_thread_ready_priority_group) - 1;
#endif

    /*获取最高优先级线程 get highest ready priority thread */
    highest_priority_thread = rt_list_entry(rt_thread_priority_table[highest_ready_priority].next,
                              struct rt_thread,
                              tlist);
    *highest_prio = highest_ready_priority;
    return highest_priority_thread;
}

代码说明1：

highest_ready_priority = __rt_ffs(rt_thread_ready_priority_group) - 1;

下面是宏定义展开：

int __rt_ffs(int value)
{
    return __builtin_ffs(value);
}

返回rt_thread_ready_priority_group的最后一位1的是从后向前第几位，比如7368（1110011001000）返回4，这是获取当前最高优先级组编号
代码说明2：

 highest_priority_thread = rt_list_entry(rt_thread_priority_table[highest_ready_priority].next,
                              struct rt_thread,
                              tlist);

这是个宏定义，也可以看做函数，用于根据结构体元素地址返回rt_thread结构体首地址。
宏定义展开：

/**
 * rt_container_of - return the member address of ptr, if the type of ptr is the
 * struct type.如果ptr的类型是struct类型，则返回ptr的成员地址。
 */
#define rt_container_of(ptr, type, member) \
    ((type *)((char *)(ptr) - (unsigned long)(&((type *)0)->member)))
参数说明
rt_thread_priority_table[highest_ready_priority].next表示当前最高优先级组表中的就绪链表中的 第一个线程就绪链表节点指针
struct rt_thread表示要返回的结构体类型
tlist表示输入的成员类型

这样根据最高优先级组编号，查找到最高优先级组，再从最高优先级组中找到第一个线程就绪链表的地址，获取到当前对应的线程控制块首地址，就可以获取到最高优先级线程的控制块。之后就可以进行后续的步骤。

线程调度器启动流程

下图是线程的初始化时被插入到就绪链表（rt_thread_priority_table）的过程：
在这里插入图片描述
启动线程调度器会启动一个优先级最高的线程，但是普通的线程的启动后（执行rt_thread_startup()函数后）还要到下一次进入SysTick_Handler中断函数中处理才能正式启动。

线程调度过程

根据线程切换的方式分为线程到线程切换和中断到线程切换。将切换的主动和被动进行区分，可以得出以下表格的内容
线程到线程切换：

情况描述主动或被动放弃CPU
调用sleep,delay函数使线程放弃CPU主动放弃
调用suspend使线程挂起主动放弃
线程的时间片耗尽被动放弃
系统产生中断,线程暂时失去CPU,中断例程执行完后没进行线程切换被动暂时放弃

中断到线程切换：

情况描述主动或被动放弃CPU
系统产生中断,线程暂时失去CPU,中断例程执行完后进行了线程切换被动放弃

当前线程的时间片用完或者该线程主动要求让出处理器资源时，它将不再占有处理器，调度器会选择相同优先级的下一个线程执行。线程调用这个接口后，这个线程仍然在就绪队列中。线程让出处理器使用下面的函数接口：

rt_err_t rt_thread_yield(void);

调用该函数后，当前线程首先把自己从它所在的就绪优先级线程队列中删除，然后把自己挂到这个优先级队列链表的尾部，然后激活调度器进行线程上下文切换（如果当前优先级只有这一个线程，则这个线程继续执行，不进行上下文切换动作）。
rt_thread_yield() 函数 和 rt_schedule() 函数比较相像，但在有相同优先级的其他就绪态线程存在时，系统的行为却完全不一样。执行 rt_thread_yield() 函数后，当前线程被换出，相同优先级的下一个就绪线程将被执行。而执行 rt_schedule() 函数后，当前线程并不一定被换出，即使被换出，也不会被放到就绪线程链表的尾部，而是在系统中选取就绪的优先级最高的线程执行（如果系统中没有比当前线程优先级更高的线程存在，那么执行完 rt_schedule() 函数后，系统将继续执行当前线程）。

与优先级相关的参数：

在启动线程函数rt_thread_startup中有如下代码:

    /* priority */
    rt_uint8_t  current_priority;                       /**< current priority 线程的当前优先级*/
    rt_uint8_t  init_priority;                          /**< initialized priority 线程的初始优先级*/
#if RT_THREAD_PRIORITY_MAX > 32
    rt_uint8_t  number;                                /**< 线程优先级对应的组号: current_priority >> 3 */
    rt_uint8_t  high_mask;                  /**< 线程位号掩码: (1 << 位号) 位号: (current_priority & 7) */
#endif
    rt_uint32_t number_mask;              /**< 组号掩码: (1 << 组号) */

在线程rt_thread_startup内,系统会调用rt_thread_resume函数将线程立即运行,而在rt_thread_resume函数中,系统会调用rt_schedule_insert_thread函数将线程加入到调试器中
接着在rt_schedule_insert_thread函数中,系统会操作线程就绪表rt_thread_ready_table将其插入就绪表最前面和修改线程就绪优先级组rt_thread_ready_priority_group的值,如下代码所示:

    /* set priority mask */
#if RT_THREAD_PRIORITY_MAX > 32
    rt_thread_ready_table[thread->number] |= thread->high_mask;
#endif
    rt_thread_ready_priority_group |= thread->number_mask;

在优先级组小于等于32时，rt_thread_ready_priority_group （就绪优先级组号）的值等于 自身与thread->number_mask（组号掩码）相或。
因此与一个线程优先级相关的参数： rt_thread_priority_table（线程就绪表）和rt_thread_ready_priority_group （线程就绪优先级组号）
这两个参数在初始化和线程启动时被设置好。线程调度时会用到。
接下来看一个时间片耗尽时线程调度的例子。

举例：时间片耗尽时线程切换的调度

线程调度器的切换和管理是由rt_schedule函数来管理的。而系统的心跳是由SysTick定时器来控制的，SysTick_Handler函数正是系统心跳的处理函数，这是最简单系统线程切换场景。
下面是SysTick_Handler函数代码：

void SysTick_Handler(void)
{
    /* enter interrupt */
    rt_interrupt_enter();
    HAL_IncTick();
    rt_tick_increase();
    /* leave interrupt */
    rt_interrupt_leave();
}

下面是rt_tick_increase函数代码：

void rt_tick_increase(void)
{
    struct rt_thread *thread;
    /* increase the global tick */
#ifdef RT_USING_SMP
    rt_cpu_self()->tick ++;
#else
    ++ rt_tick;
#endif
    /*检查时间片 check time slice */
    thread = rt_thread_self(); //获取当前正在执行的线程的控制块
    -- thread->remaining_tick; //减去一次线程运行剩余的tick值
    if (thread->remaining_tick == 0)
    {
        /*更改为原来初始化的tick值 change to initialized tick */
        thread->remaining_tick = thread->init_tick;
        thread->stat |= RT_THREAD_STAT_YIELD;
        /*放弃CPU使用权 yield */
        rt_thread_yield();
    }
    /* 检查定时器 check timer */
    rt_timer_check();
}

上面的代码执行的步骤是：

  1. 获取当前正在执行的线程的控制块
  2. 减去一次线程运行剩余的tick值
  3. 判断是否剩余tick值为0 如果为0，则将当前线程剩余tick值改为初始化时的tick值，将当前线程状态增加一个调度状态，进入调度器处理函数-rt_schedule函数
  4. 检查定时器

下面是线程状态值的定义，下面会用到与之相关的判断

线程状态定义描述16进制值2进制值
RT_THREAD_INIT初始状态0x000000
RT_THREAD_READY就绪状态0x010001
RT_THREAD_SUSPEND挂起状态0x020010
RT_THREAD_RUNNING运行状态0x030011
RT_THREAD_BLOCK阻塞状态（与挂起相同）RT_THREAD_SUSPEND
RT_THREAD_CLOSE关闭状态0x040100
RT_THREAD_STAT_MASK线程状态掩码值0x070111
RT_THREAD_STAT_YIELD调度状态0x081000
RT_THREAD_STAT_YIELD_MASK调度状态掩码值（与调度状态相同）

rt_schedule函数

执行完rt_thread_startup函数后，当前线程状态被设置为 RT_THREAD_SUSPEND（挂起状态），此时线程还没开始被CPU执行。
假设这是系统启动调度器后第一次进入tick中断中执行rt_schedule函数。

下面是rt_schedule函数代码：

void rt_schedule(void)
{
    rt_base_t level;
    struct rt_thread *to_thread;
    struct rt_thread *from_thread;
    /* 关闭中断 disable interrupt */
    level = rt_hw_interrupt_disable();
    /*检查调度程序是否已启用,调度器是否加锁 check the scheduler is enabled or not */
    if (rt_scheduler_lock_nest == 0)
    {
        rt_ubase_t highest_ready_priority;//最高优先级组编号
        if (rt_thread_ready_priority_group != 0) //如果线程优先级就绪组编号不为0，表示存在线程在就绪列表
        {
            /*需要 将from_thread 插入就绪队列 need_insert_from_thread: need to insert from_thread to ready queue */
            int need_insert_from_thread = 0;
            //获取当前最高优先级组下的最靠前就绪的线程控制块
            to_thread = _get_highest_priority_thread(&highest_ready_priority);
            //判断当前 正在运行的线程 是否正在运行状态
            if ((rt_current_thread->stat & RT_THREAD_STAT_MASK) == RT_THREAD_RUNNING)
            {   //如果当前 正在运行的线程 优先级 高于 当前就绪优先级
                if (rt_current_thread->current_priority < highest_ready_priority)
                {
                    to_thread = rt_current_thread;
                }//如果当前 正在运行的线程 优先级 等于 当前就绪优先级 且
                else if (rt_current_thread->current_priority == highest_ready_priority && (rt_current_thread->stat & RT_THREAD_STAT_YIELD_MASK) == 0)
                {
                    to_thread = rt_current_thread;
                }
                else //其它情况为需要 将 from_thread 插入就绪队列
                {
                    rt_current_thread->stat &= ~RT_THREAD_STAT_YIELD_MASK;//去掉当前线程调度状态
                    need_insert_from_thread = 1;
                }
            }
            if (to_thread != rt_current_thread)//如果目标线程与当前线程不同 则需要切换线程
            {
                /*如果目标线程与当前线程不同 if the destination thread is not the same as current thread */
                rt_current_priority = (rt_uint8_t)highest_ready_priority;
                from_thread         = rt_current_thread;
                rt_current_thread   = to_thread;
                RT_OBJECT_HOOK_CALL(rt_scheduler_hook, (from_thread, to_thread));
                if (need_insert_from_thread)
                {
                    rt_schedule_insert_thread(from_thread);
                }
                //将to_thread从就绪队列删除
                rt_schedule_remove_thread(to_thread);
                to_thread->stat = RT_THREAD_RUNNING | (to_thread->stat & ~RT_THREAD_STAT_MASK);
                /* switch to new thread */
                RT_DEBUG_LOG(RT_DEBUG_SCHEDULER,
                        ("[%d]switch to priority#%d "
                         "thread:%.*s(sp:0x%08x), "
                         "from thread:%.*s(sp: 0x%08x)\n",
                         rt_interrupt_nest, highest_ready_priority,
                         RT_NAME_MAX, to_thread->name, to_thread->sp,
                         RT_NAME_MAX, from_thread->name, from_thread->sp));
#ifdef RT_USING_OVERFLOW_CHECK
                _rt_scheduler_stack_check(to_thread);
#endif
                if (rt_interrupt_nest == 0)
                {
                    extern void rt_thread_handle_sig(rt_bool_t clean_state);
                    //将CPU控制权从from_thread切换到to_thread
rt_hw_context_switch((rt_ubase_t)&from_thread->sp,
                            (rt_ubase_t)&to_thread->sp);
                    /*开启中断响应 enable interrupt */
                    rt_hw_interrupt_enable(level);

#ifdef RT_USING_SIGNALS
                    /* check stat of thread for signal */
                    level = rt_hw_interrupt_disable();
                    if (rt_current_thread->stat & RT_THREAD_STAT_SIGNAL_PENDING)
                    {
                        extern void rt_thread_handle_sig(rt_bool_t clean_state);
                        rt_current_thread->stat &= ~RT_THREAD_STAT_SIGNAL_PENDING;
                        rt_hw_interrupt_enable(level);
                        /* check signal status */
                        rt_thread_handle_sig(RT_TRUE);
                    }
                    else
                    {
                        rt_hw_interrupt_enable(level);
                    }
#endif
                    goto __exit;
                }
                else
                {
                    RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("switch in interrupt\n"));
                    //将CPU控制权从from_thread切换到to_thread
                    rt_hw_context_switch_interrupt((rt_ubase_t)&from_thread->sp,
                            (rt_ubase_t)&to_thread->sp);
                }
            }
            else
            {
rt_schedule_remove_thread(rt_current_thread);//将rt_current_thread从就绪队列删除
                rt_current_thread->stat = RT_THREAD_RUNNING | (rt_current_thread->stat & ~RT_THREAD_STAT_MASK);//rt_current_thread添加运行状态
            }
        }
    }
    /* enable interrupt */
    rt_hw_interrupt_enable(level);
__exit:
    return;
}

rt_schedule函数的流程图

在这里插入图片描述
在这里插入图片描述

例子1：test线程切换到空闲线程

以空闲线程切换到test线程为例子，进行程序执行情况的描述。
test线程优先级为4，tick值为10，空闲线程优先级为31，tick值32.
执行步骤如下：

  1. 当test线程tick值减至0时，将tick值重新设置为初始化的值，将test线程状态添加一个调度状态，进入rt_thread_yield函数后，再进入rt_schedule函数。
  2. 关闭CPU中断响应，判断是否将调度器加锁，加锁了则直接开启中断响应并退出，未加锁继续执行。
  3. 判断当前就绪优先级组是否有就绪的线程，如果不存在则直接开启中断响应并退出，存在则继续执行。
  4. 获取目前就绪优先级组中优先级最高的线程的线程控制块
  5. 判断当前test线程是否有运行状态，当前test线程的状态值为（0B1011）是有运行态的。继续执行判断。
  6. 判断当前线程的优先级（4）是否高于目前就绪状态的线程优先级（空闲线程优先级为31），因此将to_thread赋值为 rt_current_thread。
  7. 由于to_thread的值为 rt_current_thread，将执行将当前线程从就绪列表删除，并将当前状态添加运行状态。
  8. 调度结束。

例子2：test线程切换到main线程

以空闲线程切换到test线程为例子，进行程序执行情况的描述。
test线程优先级为4，tick值为10，main线程优先级为10，tick值20.
执行步骤如下：

  1. 当test线程tick值减至0时，将tick值重新设置为初始化的值，将test线程状态添加一个调度状态，进入rt_thread_yield函数后，再进入rt_schedule函数。
  2. 关闭CPU中断响应，判断是否将调度器加锁，加锁了则直接开启中断响应并退出，未加锁继续执行。
  3. 判断当前就绪优先级组是否有就绪的线程，如果不存在则直接开启中断响应并退出，存在则继续执行。
  4. to_thread赋值为目前就绪优先级组中优先级最高的线程的线程控制块（为main线程）
  5. 判断当前执行的test线程是否有运行状态，当前test线程的状态值为（0B1010）不在运行状态。继续执行判断。
  6. 判断to_thread和rt_current_thread是否一致，目前不一致，则需要进行切换。
  7. 执行切换前的变量赋值，将rt_current_priority（当前线程优先级）设置为to_thread的线程优先级，将from_thread设置为rt_current_thread的值（为当前执行的test线程控制块），将rt_current_thread的值设置为to_thread（为main线程）。
  8. 调用钩子函数（目前不存在线程切换时的钩子函数，因此没有什么执行）
  9. 判断是否开启了插入from_thread线程的标志位，前面并没有进入这段代码，因此没有开启。跳过
  10. 将 to_thread（main线程）从就绪列表删除，给to_thread的状态添加运行状态标志。
  11. 检查如果当前线程切换过去后，此时堆栈是否溢出，如果溢出则打印信息。
  12. 判断是否给线程调度器加锁，没有加锁则执行线程切换。
  13. 执行CPU栈指针切换，将栈指针从from_thread线程切换到to_thread线程，切换过程要保存from_thread线程的完整栈信息到栈数组。
  14. 切换完毕，开启中断响应，结束退出。

总结

上述的内容只是将线程调度器在进行线程调度时候的逻辑进行了分析，与线程调度器相关的还有线程优先级的计算方法，由于篇幅原因，放到后面分析。

知识点

获取结构体首地址的宏 rt_container_of/rt_list_entry

#define rt_list_entry(node, type, member) \
    rt_container_of(node, type, member)
    
#define rt_container_of(ptr, type, member) \
    ((type *)((char *)(ptr) - (unsigned long)(&((type *)0)->member)))

说明：
rt_list_entry 这个宏的作用是通过结构体成员的地址，返回结构体的地址

参数说明
参数 node结构体成员的地址
参数 type结构体的类型
参数 member结构体的成员

&((type *)0->member) 的作用是求成员 member 在 type 结构体中的相对偏移量
例如结构体

struct test_struct 
{
    int num1;
    int num2;
    float fl;
};

成员 num1 的相对偏移量是 0，成员 num2 的相对偏移量是 4，成员 fl 的相对偏移量是 8。所以使用 ptr 的地址，减去结构体成员的相对地址，得到的就是结构体的地址。

双向链表

RT-thread线程链表管理采用的是双向链表，下面是双向链表代码定义：

/**
 * Double List structure
 */
struct rt_list_node
{
    struct rt_list_node *next;                          /**< point to next node. */
    struct rt_list_node *prev;                          /**< point to prev node. */
};
typedef struct rt_list_node rt_list_t;                  /**< Type for lists. */
元素说明
prev引用域 ，保存直接前驱结点的地址
data数据域 ，把存储据元素本身信息的域叫结点的数据域
next引用域，保存直接后继结点的地址

链表初始化

将前后引用域都指向同一个地址

rt_inline void rt_list_init(rt_list_t *l)
{
    l->next = l->prev = l;
}

双向链表后插入

/**
 * @brief insert a node after a list
 *
 * @param l list to insert it
 * @param n new node to be inserted
 */
rt_inline void rt_list_insert_after(rt_list_t *l, rt_list_t *n)
{
    l->next->prev = n;
    n->next = l->next;

    l->next = n;
    n->prev = l;
}

下图是节点N插入到L的后面：
在这里插入图片描述
双向链表前插入

/**
 * @brief insert a node before a list
 *
 * @param n new node to be inserted
 * @param l list to insert it
 */
rt_inline void rt_list_insert_before(rt_list_t *l, rt_list_t *n)
{
    l->prev->next = n;
    n->prev = l->prev;

    l->prev = n;
    n->next = l;
}

下图是节点N插入到L的前面：
在这里插入图片描述

移除链表n结点

/**
 * @brief remove node from list.
 * @param n the node to remove from the list.
 */
rt_inline void rt_list_remove(rt_list_t *n)
{
    n->next->prev = n->prev;
    n->prev->next = n->next;

    n->next = n->prev = n;
}

在这里插入图片描述
检查是否为空链表

/**
 * @brief tests whether a list is empty
 * @param l the list to test.
 */
rt_inline int rt_list_isempty(const rt_list_t *l)
{
    return l->next == l;
}

高效位运算 __builtin_系列函数

•int __builtin_ffs (unsigned int x)
返回x的最后一位1的是从后向前第几位，比如7368（1110011001000）返回4。
•int __builtin_clz (unsigned int x)
返回前导的0的个数。
•int __builtin_ctz (unsigned int x)
返回后面的0个个数，和__builtin_clz相对。
•int __builtin_popcount (unsigned int x)
返回二进制表示中1的个数。
•int __builtin_parity (unsigned int x)
返回x的奇偶校验位，也就是x的1的个数模2的结果。

此外，这些函数都有相应的usigned long和usigned long long版本，只需要在函数名后面加上l或ll就可以了，比如int __builtin_clzll。

线程调度器启动的步骤说明（补充）

下面的内容是为了完整说明线程调度器启动过程中其它与线程调度关系不大的流程的简单说明。

板级初始化

下面是板级初始化代码：

RT_WEAK void rt_hw_board_init()
{
    extern void hw_board_init(char *clock_src, int32_t clock_src_freq, int32_t clock_target_freq);
    /* Heap initialization */
#if defined(RT_USING_HEAP)  //初始化系统堆
    rt_system_heap_init((void *) HEAP_BEGIN, (void *) HEAP_END);
#endif
    //初始化系统时钟
    hw_board_init(BSP_CLOCK_SOURCE, BSP_CLOCK_SOURCE_FREQ_MHZ, BSP_CLOCK_SYSTEM_FREQ_MHZ);
    /*设置shell控制台输出设备 Set the shell console output device */
#if defined(RT_USING_DEVICE) && defined(RT_USING_CONSOLE)
    rt_console_set_device(RT_CONSOLE_DEVICE_NAME);
#endif
    /*板底层硬件初始化 Board underlying hardware initialization */
#ifdef RT_USING_COMPONENTS_INIT
    rt_components_board_init();
#endif
}
rt_system_heap_init初始化系统堆

这是系统堆管理的初始化，当前采用的是小内存管理算法，由于这段知识点篇幅较长，后面将用专门的一篇文章来讲解。

hw_board_init 初始化系统时钟

下面是hw_board_init 代码：

void hw_board_init(char *clock_src, int32_t clock_src_freq, int32_t clock_target_freq)
{
    extern void rt_hw_systick_init(void);
    extern void clk_init(char *clk_source, int source_freq, int target_freq);

#ifdef SCB_EnableICache
    /* Enable I-Cache---------------------------------------------------------*/
    SCB_EnableICache();
#endif

#ifdef SCB_EnableDCache
    /* Enable D-Cache---------------------------------------------------------*/
    SCB_EnableDCache();
#endif

    /*函数在程序开始时被调用  HAL_Init() function is called at the beginning of the program */
    HAL_Init();

    /* 启用中断enable interrupt */
    __set_PRIMASK(0);
    /* System clock initialization */
    clk_init(clock_src, clock_src_freq, clock_target_freq);
    /*关闭中断  disbale interrupt */
    __set_PRIMASK(1);

    rt_hw_systick_init();/*SysTick配置*/

    /*默认情况下，Pin驱动程序初始化处于打开状态  Pin driver initialization is open by default */
#ifdef RT_USING_PIN
    extern int rt_hw_pin_init(void);
    rt_hw_pin_init();
#endif
    /*默认情况下，USART驱动程序初始化处于打开状态  USART driver initialization is open by default */
#ifdef RT_USING_SERIAL
    extern int rt_hw_usart_init(void);
    rt_hw_usart_init();
#endif

}

hw_board_init 初始化系统时钟函数说明：

hw_board_init 参数说明
clock_src时钟来源（目前并未使用到这个参数）
clock_src_freq系统时钟初始频率，即外部晶振频率或者让内部晶振起始频率
clock_target_freq目标时钟频率（当前系统时钟频，率默认72MHz）
  1. clock_src、clock_src_freq、clock_target_freq这三个参数最终并没有调用到，因此如果需要修改系统时钟频率需要自己手动配置，建议使用STM32CubeMX软件来配置比较方便和直观。
  2. HSI 时钟信号由内部16 MHz RC 振荡器生成，可直接用作系统时钟，或者用作PLL 输入。HSI RC 振荡器的优点是成本较低（无需使用外部组件）。此外，其启动速度也要比HSE 晶振块，但即使校准后，其精度也不及外部晶振或陶瓷谐振器
  3. HSE时钟信号有两个时钟源： HSE 外部晶振/陶瓷谐振器、HSE 外部用户时钟

rt_hw_systick_init函数SysTick配置说明：

/* SysTick configuration */
void rt_hw_systick_init(void)
{
#if defined (SOC_SERIES_STM32H7)
    HAL_SYSTICK_Config((HAL_RCCEx_GetD1SysClockFreq()) / RT_TICK_PER_SECOND);
#else
    HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq() / RT_TICK_PER_SECOND);
#endif
    HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);
    HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);
}
  1. HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq() / RT_TICK_PER_SECOND);代码：用于设置SysTick时钟的频率，RT_TICK_PER_SECOND宏定义是：定义时钟节拍，为 100 时表示 100 个 tick 每秒，一个 tick 为 10ms ，
  2. HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);代码：设置时钟源分频值
  3. HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);代码：设置SysTick中断的抢占优先级和响应优先级。

rt_hw_pin_init函数和rt_hw_usart_init函数说明：
rt_hw_pin_init函数根据当前芯片型号选择打开对应的端口时钟。
rt_hw_usart_init函数会根据当前启动的串口列表分别初始化对应的串口端口。

定时器初始化

系统启动时需要初始化定时器管理系统。可以通过下面的函数完成：

void rt_system_timer_init(void)
{
    int i;
    for (i = 0; i < sizeof(rt_timer_list) / sizeof(rt_timer_list[0]); i++)
    {
        rt_list_init(rt_timer_list + i);
    }
}

定时器链表 rt_timer_list。系统新创建并激活的定时器都会按照以超时时间排序的方式插入到 rt_timer_list 链表中。
在 RT-Thread 中通过宏定义 RT_TIMER_SKIP_LIST_LEVEL 来配置跳表的层数，默认为 1，表示采用一级有序链表图的有序链表算法，每增加一，表示在原链表基础上增加一级索引。

用户main线程初始化、定时器线程初始化和空闲线程初始化

  1. main线程是默认创建的一个动态线程，方便用户使用。
  2. 定时器线程是软件定时器使用的线程，如果开启了软件定时器则需要对其初始化。初始化包括定时器的链表和线程信息初始化（线程控制块，线程栈）。
  3. 空闲线程是静态线程，一直处于就绪状态。
鸳鸯冰笔
关注
  • 1
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
[QNX 自适应分区用户指南]5 线程调度器详解
从0到1，突破自己
08-21 433
自适应分区线程调度器是一个可选的线程调度器，这个线程调度器可以让你保证线程组，进程组或应用程序组的最小CPU吞吐的百分比。分配给到分区的CPU的百分比，我们称之为预算（budget）。
rt-thread线程调度器源码分析
放飞梦想，成就未来
02-17 7819
1 前言 RT-Thread中提供的线程调度器是基于全抢占式优先级的调度，在系统中除了中断处理函数、调度器上锁部分的代码和禁止中断的代码是不可抢占的之外，系统的其他部分都是可以抢占的，包括线程调度器自身.系统总共支持256个优先级(0 ～ 255，数值越小的优先级越高，0为最高优先级，255分配给空闲线程使用，一般用户不使用。在一些资源比较紧张的系统中，可以根据情况选择只支持8个或32个优先
pthread scheduler 线程调度器
11-24
基于pthread，实现的 thread scheduler 线程调度器，并行编程，四种调度算法，时间优先 fcfs (first come first serve), 权重优先 pdb (priority), 循环 round robin, 多层反馈 multi-level feedback queue。
线程调度器
jjavaboy的专栏
01-31 2372
每个虚拟机都有一个线程调度器，确实在任何时刻运行哪个线程。有两种线程高度器： 1、抢占式（preemptive） 2、协作式（cooperative）       抢占式线程高度器确实线程何时已经公平地享用了CPU时间，然后暂停此线程上，将CPU控制权交给另外的线程。协作式线程调度器会在将CPU控制权交给其他线程前，等待运行中的线程自己斩停。与使用抢占式线程式调度的虚拟机相比，使用协作式线程
rt_container_of 作用和实现过程超级详解介绍
最新发布
qq_36720691的博客
07-24 422
rt_container_of 作用和实现过程超级详解介绍
STM32 USB主机调度器
loveliu928的博客
10-16 425
主机调度器 主机模块内置硬件调度器，可自主对应用程序发出的 USB 事务请求重新排序和管理。每一帧开始时，主机都先执行周期性（同步和中断）事务，然后执行非周期性（控制和批量）事务，以符合 USB 规范对同步和中断传输高优先级的保证。 主机通过请求队列（一个周期性请求队列和一个非周期请求队列）处理 USB 事务。每个请求队列最多可存储 8 个条目。每个条目代表一个应用程序发起但还未得到响应的 USB 事务请求，并存储了执行该 USB 事务所用到的 IN 或 OUT 通道的编...
基于STM32 HAL库的定时任务调度器例程 stm32f405ticker.zip
10-24
基于STM32 HAL库的定时任务调度器例程。 详情可以搜索博文《使用HAL库开发STM32（基于F4）：系统时间基础及进阶使用》。
IOT-OS之RT-Thread（五）--- 线程调度器与线程对象管理
流云
09-21 2333
之前的博客UCOS任务调度器与UCOS任务间通信介绍了多任务并行机制、任务调度原理、任务间同步、任务间通信等的实现原理，本文主要从RT-Thread与UCOS的对比与差异看RT-Thread线程管理与线程间同步/通信的实现。 一、线程对象管理 RT-Thread 线程管理的主要功能是对线程进行管理和调度，系统中总共存在两类线程，分别是系统线程和用户线程，系统线程是由 RT-Thread 内核创建的...
stm32f103c8t6移植RT-Thread之线程管理
01-25
在“stm32f103c8t6移植RT-Thread之线程管理”这个主题中，我们将探讨如何在STM32F103C8T6上创建和管理线程，以及线程如何与裸机程序相比提供更高级别的抽象和灵活性。 首先，我们需要了解RT-Thread的内核启动流程，...
STM32H750移植rt-thread操作系统完整工程.zip
05-17
5. **RTOS初始化**：调用rtthread_init()函数进行rt-thread的初始化，包括创建第一个线程、设置调度策略等。 6. **应用程序开发**：基于rt-thread的API开发用户应用，可以创建任务、信号量、消息队列等，实现特定的...
RTThread Stm32 标准库参考工程.zip_RT-Thread STD库_rtos stm32_rtthread_rt
07-14
在RTThread STM32标准库参考工程中，你可能找到以下关键知识点： 1. **RT-Thread初始化**：了解如何配置RT-Thread内核，包括设置系统时钟、初始化堆内存、设置中断处理等步骤。 2. **线程管理**：学习如何创建、...
小小调度器 STM32F1XX移植版本
11-09
小小调度器 STM32F1XX移植版本。 同时具备LED LCD 键盘 等驱动程序。在原子开发板上测试通过。
一种基于OSAL的STM32F103微处理器多任务作业调度机制.pdf
06-28
一种基于OSAL的STM32F103微处理器多任务作业调度机制.pdf
STM32 RT-thread与ZigBee的智能家居控制系统.7z
05-25
标题 "STM32 RT-thread与ZigBee的智能家居控制系统" 涉及到的核心技术是微控制器（STM32）、实时操作系统（RT-thread）以及无线通信协议（ZigBee），这些都是在智能家居领域中非常重要的组成部分。让我们逐一深入...
RT_ThreadPLwipRunSTM32.zip_stm32 rt thread_stm32 rt-thread_stm32
07-13
stm32跑RT_Thread实时系统+lwip实现多线程TCP服务器，并将数据转发到串口
​RT-Thread的线程调度与管理分析
FILLMOREad的博客
08-06 930
要想使用好RTOS，做出更加稳定可靠的产品，必须非常清楚底层的调度原理。由于RTOS的实时性与可控性，所以只有了解了其核心部分的设计思想，才能用起来得心应手，游刃有余。本文从RT-Thr...
什么是线程调度器(Thread Scheduler)和时间分片(Time Slicing)
qq_42233489的博客
04-12 1322
什么线程调度器： 线程调度器是一个操作系统服务，它负责为 Runnable 状态的线程分配 CPU 时间。 一旦我们创建一个线程并启动它，它的执行便依赖于线程调度器的实现。同上一个问题，线程调度并不受到 Java 虚拟机控制，所以由应用程序来控制它是 更好的选择（也就是说不要让你的程序依赖于线程的优先级）。 什么时间分片： 时间分片是指将可用的 CPU 时间分配给可用的 Runnable 线程的过程。分配 CPU 时间可以基于线程优先级或者线程等待的时间。 ...
RT-Thread线程的调度机理
glen_cao的博客
07-14 2750
RT-Thread线程的调度机理 1.何时切换线程？先引用一张官网给出的“线程状态切换图” 图1 线程状态切换图 1.1启动线程 线程初始化时，默认被设置为初始状态。线程启动后（调用rt_thread_startup），先将线程设置为挂起态，然后恢复到就绪态（调用rt_thread_resume），紧接着执行线程调度。 1.2发生阻塞（线程挂起） 1.2.1延时。若正在运行态的线程无需任何通信或...
基于STM32裸机的简单任务调度
2401_84204806的博客
04-14 981
任务调度程序（Task Scheduler）是一种能够管理多个任务按照特定的顺序或优先级执行的系统。在裸机（Bare-metal）环境中，任务调度通常是非抢占式的，意味着一个任务必须主动释放控制权，下一个任务才能开始执行。这种类型的调度器适合资源受限或实时性要求不极高的嵌入式应用。首先，定义一个任务的结构体，其中包括任务的状态、任务函数指针和可能需要的任何参数。// 任务函数，带有当前时钟周期参数// 执行周期// 最后一次执行的时钟周期// 任务当前的状态} Task;
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值