RT_Thread内核机制学习（一）

ARM架构及汇编

ARM芯片属于精简指令集计算机（RISC：Reduced Instruction Set Computer），它所使用的指令比较简单，有如下特点：

1. 对内存只有读、写指令。
2. 对于数据的运算实在CPU内部实现。
3. 使用RISC指令的CPU复杂度小一点，易于设计。

读a的值存放在CPU哪里？读b的值存放在CPU哪里？a+b的值保存在哪里？

CPU内部有寄存器，用来存放上述所说的值。

我们所写的代码保存在Flash上，C语言被处理后变成汇编指令，CPU根据这些机器码来做出相应的事情。

汇编指令

读内存指令：LDR，即Load之意。
写内存指令：STR，即Store之意。
加减指令：ADD、SUB。
跳转：BL，即Branch And Link
入栈指令：PUSH
出栈指令：POP

LDR R0,[R3]：去R3表示的内存读Data放入R0。（读4个字节）

STR R0,[R3]：把R0里的值写入到R3所指示的内存地址去。（4字节）

加减指令只在CPU内部实现，不涉及内存操作、

通用寄存器


PUSH {R0,R1}，将这两个值推进栈里。在栈的操作里，高标号寄存器放在高地址，低标号寄存器放在低地址。

PUSH = 多次调用STR，且调整SP的值。

POP{R0,R1}：R0 = [SP] SP=SP+4 R1 = [SP] SP=SP+4

BL A：记录返回地址，保存在R14（LR）；执行A，A执行完跳回地址。

什么叫线程？怎么保存线程

什么叫线程：运行中的函数，被暂停运行的函数。
怎么保存线程：把暂停瞬间的CPU寄存器值，保存进栈里。

线程核心拥有：

• 函数入口
• 栈（记录在控制块中）
• 线程控制块

1. 分配线程控制块
2. 分配栈
3. 构造栈内容。

初始化静态线程时，任务控制块和栈是事先分配好的。
动态创建线程时，任务控制块是动态分配好的。

之所以要提供两种方式创建线程，是因为有些系统不支持动态分配内存，安全性非常高的系统里，不允许动态分配内存。

内容就是stack_frame

没有R13，R13是SP，直接保存在结构体中即可。

R0保存函数参数
PC保存函数入口
LR保存函数出口

线程调度

rt_list_t rt_thread_priority_table[RT_THREAD_PRIORITY_MAX];

rt_thread_priority_table[0]
…
rt_thread_priority_table[31]

每一个优先级都有一个就绪链表

同优先级线程，每次创建一个线程插入到链表尾部。
每次取链表第一个线程运行，运行一段时间后，放入链表尾部，再找出第一个线程运行。

rt_thread_startup()只是将线程放到就绪链表，还未开始启动。

rt_system_scheduler_start()才开始调度。

int rtthread_startup(void)
{
    rt_hw_interrupt_disable();

    /* board level initialization
     * NOTE: please initialize heap inside board initialization.
     */
    rt_hw_board_init();

    /* show RT-Thread version */
    rt_show_version();

    /* timer system initialization */
    rt_system_timer_init();

    /* scheduler system initialization */
    rt_system_scheduler_init();

#ifdef RT_USING_SIGNALS
    /* signal system initialization */
    rt_system_signal_init();
#endif

    /* create init_thread */
    rt_application_init();

    /* timer thread initialization */
    rt_system_timer_thread_init();

    /* idle thread initialization */
    rt_thread_idle_init();

#ifdef RT_USING_SMP
    rt_hw_spin_lock(&_cpus_lock);
#endif /*RT_USING_SMP*/

    /* start scheduler */
    rt_system_scheduler_start();

    /* never reach here */
    return 0;
}

/**
 * @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 */
}

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;
}
#endif

使用定时器和链表来理解时间片轮转

当前任务还可以运行多少个tick，在thread->remaining_tick中记录。
每发生一次中断，thread->remainning_tick减1。
当thread->remaining_tick等于0时，要让出CPU：调用rt_thread_yield();

void SysTick_Handler(void)
{
    /* enter interrupt */
    rt_interrupt_enter();

    HAL_IncTick();
    rt_tick_increase();

    /* leave interrupt */
    rt_interrupt_leave();
}

oid rt_tick_increase(void)
{
    struct rt_thread *thread;

    /* increase the global tick */
#ifdef RT_USING_SMP
    rt_cpu_self()->tick ++;
#else
    ++ rt_tick; //全局变量tick值+1
#endif

    /* check time slice */
    thread = rt_thread_self();

    -- thread->remaining_tick; //当前线程剩余时间-1
    if (thread->remaining_tick == 0)
    {
        /* change to initialized tick */
        thread->remaining_tick = thread->init_tick;

        thread->stat |= RT_THREAD_STAT_YIELD;

        /* yield */
        rt_thread_yield();
    }

    /* check timer */
    rt_timer_check();
}

如果有更高优先级线程，即使当前线程时间片没用完，也会立刻被抢占。
当它被抢占后，再次运行时：继续运行完剩下的时间。