rt_timer 内核学习

rt_timer_start中的疑问

发布于 2024-04-17 22:30:24 浏览：381 订阅该版

下面的代码来自：RT-Thread-nano  v5.0.2

```c
rt_err_t rt_timer_start(rt_timer_t timer)
{

...

/* Interestingly, this super simple timer insert counter works very very
     * well on distributing the list height uniformly. By means of "very very
     * well", I mean it beats the randomness of timer->timeout_tick very easily
     * (actually, the timeout_tick is not random and easy to be attacked). */
    random_nr++;
    tst_nr = random_nr;

rt_list_insert_after(row_head[RT_TIMER_SKIP_LIST_LEVEL - 1],
                         &(timer->row[RT_TIMER_SKIP_LIST_LEVEL - 1]));
    for (row_lvl = 2; row_lvl <= RT_TIMER_SKIP_LIST_LEVEL; row_lvl++)
    {
        if (!(tst_nr & RT_TIMER_SKIP_LIST_MASK))
            rt_list_insert_after(row_head[RT_TIMER_SKIP_LIST_LEVEL - row_lvl],
                                 &(timer->row[RT_TIMER_SKIP_LIST_LEVEL - row_lvl]));
        else
            break;
        /* Shift over the bits we have tested. Works well with 1 bit and 2
         * bits. */
        tst_nr >>= (RT_TIMER_SKIP_LIST_MASK + 1) >> 1;
    }

...
}
```

对于上面代码中的for循环，是否应该在预编译阶段就进行判断，如下

```c
rt_err_t rt_timer_start(rt_timer_t timer)
{
    ...

#if (RT_TIMER_SKIP_LIST_LEVEL > 1)
    for (row_lvl = 2; row_lvl <= RT_TIMER_SKIP_LIST_LEVEL; row_lvl++)
    {
        if (!(tst_nr & RT_TIMER_SKIP_LIST_MASK))
            rt_list_insert_after(row_head[RT_TIMER_SKIP_LIST_LEVEL - row_lvl],
                                 &(timer->row[RT_TIMER_SKIP_LIST_LEVEL - row_lvl]));
        else
            break;
        /* Shift over the bits we have tested. Works well with 1 bit and 2
         * bits. */
        tst_nr >>= (RT_TIMER_SKIP_LIST_MASK + 1) >> 1;
    }
#endif

...
}
```

1 个回答

用户名由3_15位 2024-04-29

代码总在「分分钟搞定」的狂喜与「必有暗坑」的隐忧间往复

- 修改代码段如下

```c
    row_head[0]  = &timer_list[0];
    for (row_lvl = 0; row_lvl < RT_TIMER_SKIP_LIST_LEVEL; row_lvl++)
    {
        for (; row_head[row_lvl] != timer_list[row_lvl].prev;
             row_head[row_lvl]  = row_head[row_lvl]->next)
        {
            struct rt_timer *t;
            rt_list_t *p = row_head[row_lvl]->next;

/* fix up the entry pointer */
            t = rt_list_entry(p, struct rt_timer, row[row_lvl]);

/* If we have two timers that timeout at the same time, it's
             * preferred that the timer inserted early get called early.
             * So insert the new timer to the end the the some-timeout timer
             * list.
             */
            if ((t->timeout_tick - timer->timeout_tick) == 0)
            {
                continue;
            }
            else if ((t->timeout_tick - timer->timeout_tick) < RT_TICK_MAX / 2)
            {
                break;
            }
        }
#if (RT_TIMER_SKIP_LIST_LEVEL > 1)
        if (row_lvl != RT_TIMER_SKIP_LIST_LEVEL - 1)
            row_head[row_lvl + 1] = row_head[row_lvl] + 1;
#endif //RT_TIMER_SKIP_LIST_LEVEL > 1
    }

/* Interestingly, this super simple timer insert counter works very very
     * well on distributing the list height uniformly. By means of "very very
     * well", I mean it beats the randomness of timer->timeout_tick very easily
     * (actually, the timeout_tick is not random and easy to be attacked). */
    random_nr++;
    tst_nr = random_nr;

rt_list_insert_after(row_head[RT_TIMER_SKIP_LIST_LEVEL - 1],
                         &(timer->row[RT_TIMER_SKIP_LIST_LEVEL - 1]));

#if (RT_TIMER_SKIP_LIST_LEVEL > 1)
    for (row_lvl = 2; row_lvl <= RT_TIMER_SKIP_LIST_LEVEL; row_lvl++)
    {
        if (!(tst_nr & RT_TIMER_SKIP_LIST_MASK))
            rt_list_insert_after(row_head[RT_TIMER_SKIP_LIST_LEVEL - row_lvl],
                                 &(timer->row[RT_TIMER_SKIP_LIST_LEVEL - row_lvl]));
        else
            break;
        /* Shift over the bits we have tested. Works well with 1 bit and 2
         * bits. */
        tst_nr >>= (RT_TIMER_SKIP_LIST_MASK + 1) >> 1;
    }
#endif //RT_TIMER_SKIP_LIST_LEVEL > 1
```

- KEIL AC6 -O0编译 未执行宏条件判断
```c
Total RO  Size (Code + RO Data)               400896 ( 391.50kB)
    Total RW  Size (RW Data + ZI Data)             25080 (  24.49kB)
    Total ROM Size (Code + RO Data + RW Data)     401632 ( 392.22kB)
```

- KEIL AC6 -O0编译 执行宏条件判断
```c
    Total RO  Size (Code + RO Data)               400808 ( 391.41kB)
    Total RW  Size (RW Data + ZI Data)             25080 (  24.49kB)
    Total ROM Size (Code + RO Data + RW Data)     401544 ( 392.13kB)
```

- KEIL AC6 -Oz编译 不执行宏条件判断

```c
    Total RO  Size (Code + RO Data)               233208 ( 227.74kB)
    Total RW  Size (RW Data + ZI Data)             24864 (  24.28kB)
    Total ROM Size (Code + RO Data + RW Data)     233816 ( 228.34kB)
```

- KEIL AC6 -Oz编译 执行宏条件判断

```c
    Total RO  Size (Code + RO Data)               233208 ( 227.74kB)
    Total RW  Size (RW Data + ZI Data)             24864 (  24.28kB)
    Total ROM Size (Code + RO Data + RW Data)     233816 ( 228.34kB)
```

- 综上可以分析出,在低优化等级下,使用这个宏去判断是可以减少占用的

https://github.com/RT-Thread/rt-thread/pull/8884