20190925（6）RT-Thread 线程管理源码解读（3）初始化相关函数及位操作讲解

Bertha 。 2023-10-09 11:41 27阅读 0赞

##### 目的： #####

1 解读篇幅 2 中遗留代码 rt\_memset()/rt\_hw\_stack\_init()/rt\_timer\_init()  
2 位操作补充说明 以及 原码 补码 反码 说明

--------------------

##### 正文 #####

##### 遗留代码解读 #####

1.  rt\_memset()
2.  rt\_hw\_stack\_init()
3.  rt\_timer\_init()

//filePath: /src/thread.c
    /**
     * This function will set the content of memory to specified value //为存储空间设定指定值
     *
     * @param s the address of source memory
     * @param c the value shall be set in content
     * @param count the copied length
     *
     * @return the address of source memory
     */
    void *rt_memset(void *s, int c, rt_ubase_t count)
    {
    #ifdef RT_USING_TINY_SIZE //使用小空间
        char *xs = (char *)s;
    
        while (count--)
            *xs++ = c;
    
        return s;
    #else
    #define LBLOCKSIZE      (sizeof(long))  //大尺寸 long => 4 bytes
    #define UNALIGNED(X)    ((long)X & (LBLOCKSIZE - 1)) 
    // & 第一用法，A & B 只要 A 为false则直接输出 false, && 则 A/B 都会判断
    // & 第二用法，取模 15 % 4 == 15 & (4-1) 
    
    #define TOO_SMALL(LEN)  ((LEN) < LBLOCKSIZE)
    
        unsigned int i;
        char *m = (char *)s;
        unsigned long buffer;
        unsigned long *aligned_addr;
        unsigned int d = c & 0xff;  /* To avoid sign extension, copy C to an
                                    unsigned variable.  */
    
        if (!TOO_SMALL(count) && !UNALIGNED(s)) //对于大尺寸
        {
            /* If we get this far, we know that n is large and m is word-aligned. */
            aligned_addr = (unsigned long *)s;
    
            /* Store D into each char sized location in BUFFER so that
             * we can set large blocks quickly.
             */
            if (LBLOCKSIZE == 4) //32bit 环境
            {
                buffer = (d << 8) | d;
                buffer |= (buffer << 16);
            }
            else //8 bit 环境
            {
                buffer = 0;
                for (i = 0; i < LBLOCKSIZE; i ++)
                    buffer = (buffer << 8) | d;
            }
    
            while (count >= LBLOCKSIZE * 4) //这个就是按照2字节16bit进行快速初始化
            {
                *aligned_addr++ = buffer;
                *aligned_addr++ = buffer;
                *aligned_addr++ = buffer;
                *aligned_addr++ = buffer;
                count -= 4 * LBLOCKSIZE;
            }
    
            while (count >= LBLOCKSIZE)//对于剩余进行初始化
            {
                *aligned_addr++ = buffer;
                count -= LBLOCKSIZE;
            }
    
            /* Pick up the remainder with a bytewise loop. */
            m = (char *)aligned_addr;
        }
    
        while (count--)
        {
            *m++ = (char)d;
        }
    
        return s;
    
    #undef LBLOCKSIZE
    #undef UNALIGNED
    #undef TOO_SMALL
    #endif
    }
    RTM_EXPORT(rt_memset);

--------------------

//filePath: /libcpu/arm/cortex-m4/cpuport.c
    rt_uint8_t *rt_hw_stack_init(void       *tentry,
                                 void       *parameter,
                                 rt_uint8_t *stack_addr,
                                 void       *texit)
    {
        struct stack_frame *stack_frame;
        rt_uint8_t         *stk;
        unsigned long       i;
    
        stk  = stack_addr + sizeof(rt_uint32_t);//得到栈顶位置 stk: A-------Z(当前位置)
        stk  = (rt_uint8_t *)RT_ALIGN_DOWN((rt_uint32_t)stk, 8); //8字节对齐
        stk -= sizeof(struct stack_frame);//重新得到对齐后，栈底指针位置 stk: 未知(当前位置)-----Z
    
        stack_frame = (struct stack_frame *)stk;
    
        /* init all register */
        for (i = 0; i < sizeof(struct stack_frame) / sizeof(rt_uint32_t); i ++)
        {
            ((rt_uint32_t *)stack_frame)[i] = 0xdeadbeef; //这个只是一个特定声明的16进制，不需要在意含义
        }
    
        stack_frame->exception_stack_frame.r0  = (unsigned long)parameter; /* r0 : argument */
        stack_frame->exception_stack_frame.r1  = 0;                        /* r1 */
        stack_frame->exception_stack_frame.r2  = 0;                        /* r2 */
        stack_frame->exception_stack_frame.r3  = 0;                        /* r3 */
        stack_frame->exception_stack_frame.r12 = 0;                        /* r12 */
        stack_frame->exception_stack_frame.lr  = (unsigned long)texit;     /* lr */
        stack_frame->exception_stack_frame.pc  = (unsigned long)tentry;    /* entry point, pc */
        stack_frame->exception_stack_frame.psr = 0x01000000L;              /* PSR */
    
    #if USE_FPU //FPU 是浮点运算芯片的含义
        stack_frame->flag = 0;
    #endif /* USE_FPU */
    
        /* return task's current stack address */
        return stk;
    }

--------------------

//filePath: /src/thread.c
    /**
     * This function will initialize a timer, normally this function is used to
     * initialize a static timer object. //初始化静态定时器对象
     *
     * @param timer the static timer object //对象指针
     * @param name the name of timer //名称
     * @param timeout the timeout function //超时后执行的函数
     * @param parameter the parameter of timeout function //函数参数
     * @param time the tick of timer //时间长度（多少之后算超时）
     * @param flag the flag of timer //支持的值包括单次定时、周期定时、 硬件定时器、软件定时器（可以用 “或” 关系取多个值）
    
     */
    void rt_timer_init(rt_timer_t  timer,
                       const char *name,
                       void (*timeout)(void *parameter),
                       void       *parameter,
                       rt_tick_t   time,
                       rt_uint8_t  flag)
    {
        /* timer check */
        RT_ASSERT(timer != RT_NULL);
    
        /* timer object initialization */
        rt_object_init((rt_object_t)timer, RT_Object_Class_Timer, name); 
        //初始化对象，并将该对象加入到系统对象管理列表中（具体可以不在意实现过程，不重要）
    
        _rt_timer_init(timer, timeout, parameter, time, flag); //就是将各类参数写入结构的函数，不重要
    }

--------------------

#### 位操作拓展说明 ####

<table> 
 <thead> 
  <tr> 
   <th>符号</th> 
   <th>描述</th> 
   <th>公式</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>&amp;</td> 
   <td>与</td> 
   <td>两位都为 1，则 A &amp; B = 1 否则为 0</td> 
  </tr> 
  <tr> 
   <td>l</td> 
   <td>或</td> 
   <td>只要有 1，输出 1</td> 
  </tr> 
  <tr> 
   <td>^</td> 
   <td>异或</td> 
   <td>两个位相同为0，相异为1</td> 
  </tr> 
  <tr> 
   <td>~</td> 
   <td>取反</td> 
   <td>0-&gt;1, 1-&gt;0 (了解 原码 反码 补码)</td> 
  </tr> 
  <tr> 
   <td>&lt;&lt;</td> 
   <td>左移</td> 
   <td>a &lt;&lt; n ==&gt; a * 2^n</td> 
  </tr> 
  <tr> 
   <td>&gt;&gt;</td> 
   <td>右移</td> 
   <td>b &gt;&gt; b ==&gt; a / 2^n</td> 
  </tr> 
 </tbody> 
</table>

--------------------

> ^ 说明经典用法就是两个变量相互赋值  
> 普通版本： A/B 互换； C = A; A = B; B = C;  
> 高端版本：前提知道 A = A ^ B ^ B; 计算：A ^= B; B ^ = A; A ^= B;

> & 拓展说明
> 
> 1.  & 第一用法，A & B 只要 A 为false则直接输出 false, && 则 A/B 都会判断
> 2.  & 第二用法，取模 15 % 4 == 15 & (4-1) [详细数学用法][Link 1]
> 3.  & 第三用法，&A 取出 A 变量的地址

> l 拓展说明：常用于赋值  
> A = B0001; A |= 1<<1== > B0001 | B0010 = B0011

> ~ 拓展  
> ~（B001) ==> B110

> ! 拓展  
> 只要是真 !A = 0; 只要是假 !A = 1;

--------------------

源码 补码 反码  
[详细说明][Link 2]

> 源码：有正负的数字  
> 1 ==> 0000 0001 / -1 ==> 1000 0001 （用第一位 1 表示负号）

> 反码：反码的表示方法是:正数的反码是其本身,负数的反码是在其原码的基础上, 符号位不变，其余各个位取反.  
> \[+1\] = \[00000001\]原 = \[00000001\]反  
> \[-1\] = \[10000001\]原 = \[11111110\]反

> 补码：补码的表示方法是:正数的补码就是其本身 负数的补码是在其原码的基础上, 符号位不变, 其余各位取反, 最后+1. (即在反码的基础上+1)  
> \[+1\] = \[00000001\]原 = \[00000001\]反 = \[00000001\]补  
> \[-1\] = \[10000001\]原 = \[11111110\]反 = \[11111111\]补

[Link 1]: https://www.cnblogs.com/bytebee/p/8194677.html
[Link 2]: https://www.cnblogs.com/maoypeng/archive/2018/06/01/9123826.html