RT_ Thread ask and answer

Looking at Mr. Wei Dongshan “RT-Thread Internal mechanism ” In the video , That's interesting , The understanding of some concepts still needs to be studied deeply , Or it could be “ That's true. , This is not that .... that .... that ”, Which one , It's not because you're stupid and can't say well , It's because I really didn't think about it. I really don't know , Here are some questions and answers .

1、 What is a thread ？

I understand it , Thread is to direct the operation of function .【 A thread corresponds to an entry function 】

• control ta When to run , How long can it run ;
• When pausing to switch to another thread , Save the current environment , In order to continue running next time ;

2、 What is the environment to save when switching threads ？

The first function is existence FLASH Medium , No need to save ;

The second is the variables used in the function , Including global variables and local variables , All variables can be used by everyone without thread saving , Local variables are stored in their respective thread stacks ;

If you don't know what to bring when the thread leaves , You can think about what to do when you continue to run ？

You need to know which one （ assembly ） Statement start execution , What will be used in the implementation CPU Middle register Value , This is what we want to keep .

P.S. CPU Middle register , Including parameter register , Status register , So-called “ Where to execute ” The program counter of PC etc. .

3、 What did you do when you created the thread ？

use rt_thread_init or rt_thread_create Create thread , We passed some parameters ： Entry function 、 Function parameter 、 Thread stack 、 priority 、 Time slice , Then the thread is created .

emm... Put the duck and beer in the pot , It won't turn into a beer duck .

With rt_thread_create For example ：

• apply Memory of thread control block ; apply Memory of thread stack ;
• Initialize thread linked list ;
• Initialize various parameters of thread control block ： Function entrance 、 Function parameter 、 The starting address of the stack 、 Stack size 、 Thread mask 、 Initial time slice 、 Time remaining 、 Thread error code 、 Thread state 、 Thread cleanup function 、 User data ;
• Initialize the thread stack ;
• Initialize thread timer ;
• Initialize thread hook function ;

3.1、 Initialize the thread stack

First, the memory of the thread stack applied for , All initialized to '#';

rt_memset(thread->stack_addr, '#', thread->stack_size);

And then call rt_hw_stack_init Function initialization stack ;

    thread->sp = (void *)rt_hw_stack_init(thread->entry, thread->parameter,
                                          (rt_uint8_t *)((char *)thread->stack_addr + thread->stack_size - sizeof(rt_ubase_t)),
                                          (void *)rt_thread_exit);

The third parameter stack_addr+stack_size-8,stack_addr Is the address allocated when applying for memory , Indicates the low address at the bottom of the stack , Add stack_size At the top of the stack , Then subtract 8. Enter the function and add 4, With 8 Bit multiples are aligned downward , Anyway, one pass operation is to find the address at the top of the stack after alignment .

There is one in the function Structure stack_frame, It's preservation CPU The value of the register , The definition is as follows ： 

struct exception_stack_frame
{
    rt_uint32_t r0;
    rt_uint32_t r1;
    rt_uint32_t r2;
    rt_uint32_t r3;
    rt_uint32_t r12;
    rt_uint32_t lr;
    rt_uint32_t pc;
    rt_uint32_t psr;
};

struct stack_frame
{
#if USE_FPU
    rt_uint32_t flag;
#endif /* USE_FPU */

    /* r4 ~ r11 register */
    rt_uint32_t r4;
    rt_uint32_t r5;
    rt_uint32_t r6;
    rt_uint32_t r7;
    rt_uint32_t r8;
    rt_uint32_t r9;
    rt_uint32_t r10;
    rt_uint32_t r11;

    struct exception_stack_frame exception_stack_frame;
};

3.2、 Initialize thread hook function

• Initialize the hook function of the thread , What is called is the code 1;
• RT_OBJECT_HOOK_CALL A macro , A macro definition is code 2;
• hypothesis func != NULL, Expanding the macro is code 3;
• rt_thread_inited_hook It's a function pointer , Definition is code 4;
• This function pointer rt_thread_inited_hook In function rt_thread_inited_sethook Is assigned to , The following code 5;
• Last ,rt_thread_inited_sethook It's for users , The hook function set will be called when the thread is initialized ;

1、RT_OBJECT_HOOK_CALL(rt_thread_inited_hook, (thread));

2、#define RT_OBJECT_HOOK_CALL(func, argv) \
      do { if ((func) != RT_NULL) func argv; } while (0)

3、rt_thread_inited_hook(thread);

4、static void (*rt_thread_inited_hook) (rt_thread_t thread);

5、 void rt_thread_inited_sethook(void (*hook)(rt_thread_t thread))
    {
        rt_thread_inited_hook = hook;
    }

4、 After creating the thread , Thread start rt_thread_startup What did you do ？

In short The thread enters the ready state from the initial state , Thread inserted into ready queue , then rt_schedule Kernel scheduling , As follows ：

5、SysTick_Handler What are the operations in ？

SysTick_Handler In the call rt_tick_increase,rt_tick_increase I did two things ：

• Check the currently running thread , See if the time slice is used up , Run out of execution rt_schedule Scheduling switching threads ;
• Check the timer list , See if there is a timeout overflow , Execute timer callback function ;