rtx 写的真有那么牛！！！？？？

myxiaonia

之前看其手册和坛友讨论，觉得必须好好研究其优越性，这段时间一直在看rtx的源码，情况似乎有些不尽人意


不说之前对membox的alloc和free函数封皮的疑问，现在看到mutex部分，疑问更加大了？？？

1. OS_RESULT rt_mut_release (OS_ID mutex)
   
2. {
   
3. ...
   
4.   /* Remove mutex from task mutex owner list. */
   
5.   p_mlnk = os_tsk.run->p_mlnk;
   
6.   if (p_mlnk == p_MCB) {
   
7.     os_tsk.run->p_mlnk = p_MCB->p_mlnk;
   
8.   }
   
9.   else {
   
10.     while (p_mlnk) {
    
11.       if (p_mlnk->p_mlnk == p_MCB) {
    
12.         p_mlnk->p_mlnk = p_MCB->p_mlnk;
    
13.         break;
    
14.       }
    
15.       p_mlnk = p_mlnk->p_mlnk;
    
16.     }
    
17.   }
    
18. 
    
19.   /* Restore owner task's priority. */
    
20.   prio = os_tsk.run->prio_base;
    
21.   p_mlnk = os_tsk.run->p_mlnk;
    
22.   while (p_mlnk) {
    
23.     if (p_mlnk->p_lnk && (p_mlnk->p_lnk->prio > prio)) {
    
24.       /* A task with higher priority is waiting for mutex. */
    
25.       prio = p_mlnk->p_lnk->prio;
    
26.     }
    
27.     p_mlnk = p_mlnk->p_mlnk;
    
28.   }
    
29.   os_tsk.run->prio = prio;
    
30.   if (p_MCB->p_lnk != NULL) {
    
31. ...                                        //这段代码段已忽略------互斥量释放给其等待任务，这个等待任务获得了这个互斥量
    
32.   }
    
33.   else {
    
34.     /* Check if own priority lowered by priority inversion. */
    
35.     if (rt_rdy_prio() > os_tsk.run->prio) {
    
36.       rt_put_prio (&os_rdy, os_tsk.run);
    
37.       os_tsk.run->state = READY;
    
38.       rt_dispatch (NULL);
    
39.       os_tsk.run->ret_val = OS_R_OK;
    
40.     }
    
41.   }
    
42. 
    
43. }

复制代码

这个释放互斥量的链表操作一点都不简练，可以使用二级指针嘛，之前看到linus大神批判一个链表删除操作的问题，一模一样；然后是优先级恢复，怎么也应该先判断下释放的互斥量任务列表有没有导致优先级变化嘛；而且这里2个遍历互斥量链表操作，难道就不能合并在一起？？？优化工作很不到位啊
最后这个检查更是让人觉得笑掉大牙，这个互斥量都没有等待的任务链表，怎么可能会有优先级变化呢，更不要说降低了，实在是太不严谨了！！！！



呼唤wuzhujian大神答疑解惑

DWDM

以前不懂系统的时候用过这个，后来玩ucos

myxiaonia

DWDM 发表于 2014-6-2 16:47
以前不懂系统的时候用过这个，后来玩ucos

可有对着两个系统的研究？？？网上说ucos2，内核效率绝对杠杠的，只是没有对cm3系列优化过，如果这个rtx评估到最后感觉不好，再去评估下ucos2把，，，，freertos又怎么样呢？

fengyunyu

有批评才有进步，学习！

kinsno

myxiaonia 发表于 2014-6-2 16:51
可有对着两个系统的研究？？？网上说ucos2，内核效率绝对杠杠的，只是没有对cm3系列优化过，如果这个rtx ...

哈哈，我一直在盯着你的笔记呢？不过话说对RTX一窍不通，没时间去折腾啊，UCOS2和UCOS3都用过，谈不上精通，基本跑着做产品问题是不大了；但依然不太想用，个人不喜欢掌控不住的东西；可能是早年写裸奔写多了的程序洁癖吧

myxiaonia

kinsno 发表于 2014-6-2 17:09
哈哈，我一直在盯着你的笔记呢？不过话说对RTX一窍不通，没时间去折腾啊，UCOS2和UCOS3都用过，谈不上精 ...

这不是在深入学习么，嘿嘿

wuzhujian

rtx的线程，有可能同时位于2个链表中：
1> 信号量、互斥量、队列等的等待链表；
2> 延时的计时链表。

因为有2个同时存在的双向链表，所以要设计2组指针，分别用于这2个链表的操作。

互斥量的主要应用场合是：保护一段代码互斥的访问。所以，一样有等待线程链表。
信号量的主要应用场合是：保护数据的互斥访问。所以，很多时候，互斥量与信号量可以通用。

但这二者是有区别的。

lcl

搬凳子学习。。。。。。。。。

myxiaonia

wuzhujian 发表于 2014-6-2 18:50
rtx的线程，有可能同时位于2个链表中：
1> 信号量、互斥量、队列等的等待链表；
2> 延时的计时链表。

确实如此，从TCB结构体中可以看到这2个双向链表的4个指针

之前这个函数的第3个代码 段，很明显这个互斥量没有等待任务，因此当前任务必定不会有优先级变化的疑问，所以这个代码段完全可以去掉，是这样的道理吗？

lulu爱

raw-os的mutex的逻辑严谨性是目前rtos中几乎是最严谨的，mutex的逻辑是内核中最复杂的，因为涉及到优先级反转的重大问题。

prince2010

顶一个

myxiaonia

这是最后修改的rt_mut_release函数，又修改了当释放互斥量的等待任务调度回来和当前任务运行的情况，原来的思路还是不清啊，只需要当前任务和此调度任务进行互相比较优先级即可，大家看看是不是简洁不少啊

1. OS_RESULT rt_mut_release (OS_ID mutex) {
   
2.   /* Release a mutex object */
   
3.   P_MUCB p_MCB = mutex;
   
4.   P_TCB  p_TCB;
   
5.   P_TCB  prun = os_tsk.run;
   
6. 
   
7.   if (p_MCB->level == 0 || p_MCB->owner != prun) {
   
8.     /* Unbalanced mutex release or task is not the owner */
   
9.     return (OS_R_NOK);
   
10.   }
    
11.   if (--p_MCB->level != 0) {
    
12.     return (OS_R_OK);
    
13.   }
    
14. 
    
15.   /* Remove mutex from task mutex owner list. */
    
16.   {
    
17.           P_MUCB *p = &prun->p_mlnk;
    
18.           do
    
19.           {
    
20.                   if (*p == p_MCB) {
    
21.                         *p = (*p)->p_mlnk;break;
    
22.                   }
    
23.                   else
    
24.                   {
    
25.                           p = &(*p)->p_mlnk;
    
26.                   }
    
27.           }while(*p);
    
28.   }
    
29. 
    
30.   if (p_MCB->p_lnk != NULL) {
    
31.     /* Restore owner task's priority. */
    
32.     if(p_MCB->p_lnk->prio >= prun->prio_base)
    
33.     {
    
34.           U8 prio = prun->prio_base;
    
35.             P_MUCB  p_mlnk = prun->p_mlnk;
    
36.             while (p_mlnk != NULL) {
    
37.                   if (p_mlnk->p_lnk != NULL && (p_mlnk->p_lnk->prio > prio)) {
    
38.                     /* A task with higher priority is waiting for mutex. */
    
39.                     prio = p_mlnk->p_lnk->prio;
    
40.                   }
    
41.                   p_mlnk = p_mlnk->p_mlnk;
    
42.             }
    
43.             prun->prio = prio;
    
44.     }
    
45.     /* A task is waiting for mutex. */
    
46.     p_TCB = rt_get_first ((P_XCB)p_MCB);
    
47.     rt_rmv_dly (p_TCB);
    
48.     /* A waiting task becomes the owner of this mutex. */
    
49.     p_MCB->level  = 1;
    
50.     p_MCB->owner  = p_TCB;
    
51.     p_MCB->p_mlnk = p_TCB->p_mlnk;
    
52.     p_TCB->p_mlnk = p_MCB;
    
53.     p_TCB->ret_val = OS_R_MUT;
    
54.         prun->ret_val = OS_R_OK;
    
55.     /* Priority inversion, check which task continues. */
    
56.     rt_dispatch (p_TCB);
    
57.     return (OS_R_OK);
    
58. }

复制代码

hejiang177

kinsno 发表于 2014-6-2 17:09
哈哈，我一直在盯着你的笔记呢？不过话说对RTX一窍不通，没时间去折腾啊，UCOS2和UCOS3都用过，谈不上精 ...

我现在也喜欢裸奔