ThreadX内核源码分析 - 计数信号量

1、计数信号量介绍

计数信号量的信号量值不为0，表示信号量可获取，每次获取信号量，信号量计数器的值减1，为0是，信号量不看获取，释放信号量是每次加1；

计数信号量实现与互斥锁类似，一定程度上可以把互斥锁看出计数为1的信号量，只不过互斥锁有动态优先级调整，信号量没有，互斥锁用于临界资源保护，信号量用于生产消费者这类场景(多个消费者、多个生产者)。

2、信号量获取_tx_semaphore_get

获取信号量的代码比较简单，主要是对计数信号量的计数进行判断，如果信号量计数器不为0，就减1然后返回(获取到了信号量)，如果信号量计数器为0(获取不到信号量)，那么设置自己的阻塞状态，设置超时/终止等情况下的清理函数，设置阻塞的信号量，将自己加入到信号量的阻塞队列，挂起自己，内核的挂起函数在挂起当前线程是会选择下一个执行线程并进行线程切换(切换过程当然也会保存当前线程的上下文)。

_tx_semaphore_get实现代码如下：

076 UINT  _tx_semaphore_get(TX_SEMAPHORE *semaphore_ptr, ULONG wait_option)
077 {
078 
079 TX_INTERRUPT_SAVE_AREA
080             
081 TX_THREAD       *thread_ptr;
082 TX_THREAD       *next_thread;
083 TX_THREAD       *previous_thread;
084 UINT            status;
085 
086 
087     /* Default the status to TX_SUCCESS.  */
088     status =  TX_SUCCESS;
089 
090     /* Disable interrupts to get an instance from the semaphore.  */
091     TX_DISABLE
092 
093 #ifdef TX_SEMAPHORE_ENABLE_PERFORMANCE_INFO
094 
095     /* Increment the total semaphore get counter.  */
096     _tx_semaphore_performance_get_count++;
097 
098     /* Increment the number of attempts to get this semaphore.  */
099     semaphore_ptr -> tx_semaphore_performance_get_count++;
100 #endif
101 
102     /* If trace is enabled, insert this event into the trace buffer.  */
103     TX_TRACE_IN_LINE_INSERT(TX_TRACE_SEMAPHORE_GET, semaphore_ptr, wait_option, semaphore_ptr -> tx_semaphore_count, TX_POINTER_TO_ULONG_CONVERT(&thread_ptr), TX_TRACE_SEMAPHORE_EVENTS)
104 
105     /* Log this kernel call.  */
106     TX_EL_SEMAPHORE_GET_INSERT
107 
108     /* Determine if there is an instance of the semaphore.  */
109     if (semaphore_ptr -> tx_semaphore_count != ((ULONG) 0)) // 信号量计数器不为0，可以获取到信号量
110     {
111 
112         /* Decrement the semaphore count.  */
113         semaphore_ptr -> tx_semaphore_count--; // 简单对计数信号量减1即可，然后返回成功(与互斥锁不同，计数信号量没有记录owner)
114 
115         /* Restore interrupts.  */
116         TX_RESTORE
117     }
118 
119     /* Determine if the request specifies suspension.  */
120     else if (wait_option != TX_NO_WAIT) // 信号量为0，获取不到信号量，并且wait_option不是TX_NO_WAIT，也就是获取信号量是阻塞的
121     {
122 
123         /* Determine if the preempt disable flag is non-zero.  */
124         if (_tx_thread_preempt_disable != ((UINT) 0)) // 如果禁止了抢占，那么不能阻塞获取不到信号量的线程，否则所有其他就绪线程都得不到调度
125         {
126     
127             /* Restore interrupts.  */
128             TX_RESTORE
129 
130             /* Suspension is not allowed if the preempt disable flag is non-zero at this point - return error completion.  */
131             status =  TX_NO_INSTANCE; // 获取不到信号量，禁止抢占，返回TX_NO_INSTANCE即可
132         }
133         else // 没有禁止抢占，获取不到信号量的线程可以进入阻塞状态
134         {
135 
136             /* Prepare for suspension of this thread.  */
137 
138 #ifdef TX_SEMAPHORE_ENABLE_PERFORMANCE_INFO
139 
140             /* Increment the total semaphore suspensions counter.  */
141             _tx_semaphore_performance_suspension_count++;
142 
143             /* Increment the number of suspensions on this semaphore.  */
144             semaphore_ptr -> tx_semaphore_performance_suspension_count++;
145 #endif
146             
147             /* Pickup thread pointer.  */
148             TX_THREAD_GET_CURRENT(thread_ptr) // 获取当前线程_tx_thread_current_ptr
149 
150             /* Setup cleanup routine pointer.  */
151             thread_ptr -> tx_thread_suspend_cleanup =  &(_tx_semaphore_cleanup); // 设置超时清理函数_tx_semaphore_cleanup(与前面文章介绍的获取内存阻塞一样，超时需要通过_tx_semaphore_cleanup唤醒线程并且从等待信号量队列删除线程)
152 
153             /* Setup cleanup information, i.e. this semaphore control
154                block.  */
155             thread_ptr -> tx_thread_suspend_control_block =  (VOID *) semaphore_ptr; // 阻塞在信号量semaphore_ptr上(线程挂在semaphore_ptr等待链表上，_tx_semaphore_cleanup及释放信号量的线程需要通过semaphore_ptr找到等待信号量的线程)
156 
157 #ifndef TX_NOT_INTERRUPTABLE
158 
159             /* Increment the suspension sequence number, which is used to identify
160                this suspension event.  */
161             thread_ptr -> tx_thread_suspension_sequence++;
162 #endif
163 
164             /* Setup suspension list.  */
165             if (semaphore_ptr -> tx_semaphore_suspended_count == TX_NO_SUSPENSIONS) // 只有当前线程等待信号量，加入tx_semaphore_suspension_list信号量等待链表
166             {
167 
168                 /* No other threads are suspended.  Setup the head pointer and
169                    just setup this threads pointers to itself.  */
170                 semaphore_ptr -> tx_semaphore_suspension_list =         thread_ptr;
171                 thread_ptr -> tx_thread_suspended_next =                thread_ptr;
172                 thread_ptr -> tx_thread_suspended_previous =            thread_ptr;
173             }
174             else // 有多个线程等待信号量，加入tx_semaphore_suspension_list信号量等待链表，添加到末尾
175             {
176 
177                 /* This list is not NULL, add current thread to the end. */
178                 next_thread =                                   semaphore_ptr -> tx_semaphore_suspension_list;
179                 thread_ptr -> tx_thread_suspended_next =        next_thread;
180                 previous_thread =                               next_thread -> tx_thread_suspended_previous;
181                 thread_ptr -> tx_thread_suspended_previous =    previous_thread;
182                 previous_thread -> tx_thread_suspended_next =   thread_ptr;
183                 next_thread -> tx_thread_suspended_previous =   thread_ptr;
184             }
185 
186             /* Increment the number of suspensions.  */
187             semaphore_ptr -> tx_semaphore_suspended_count++; // 等待信号量的线程个数加1
188 
189             /* Set the state to suspended.  */
190             thread_ptr -> tx_thread_state =    TX_SEMAPHORE_SUSP; // 设置当前线程的状态，等待信号量超时需要判断状态，其他一些唤醒阻塞操作也需要判断状态(一些状态的线程不能被唤醒或者挂起，或者说线程处于不可中断的阻塞状态)
191 
192 #ifdef TX_NOT_INTERRUPTABLE
193 
194             /* Call actual non-interruptable thread suspension routine.  */
195             _tx_thread_system_ni_suspend(thread_ptr, wait_option);
196 
197             /* Restore interrupts.  */
198             TX_RESTORE
199 #else
200 
201             /* Set the suspending flag.  */
202             thread_ptr -> tx_thread_suspending =  TX_TRUE; // 设置tx_thread_suspending，线程还没从就绪链表删除
203 
204             /* Setup the timeout period.  */
205             thread_ptr -> tx_thread_timer.tx_timer_internal_remaining_ticks =  wait_option; // 等待超时时间，如果wait_option不是无限等待，那么_tx_thread_system_suspend挂起线程时就会启动一个定时器，超时调用tx_thread_suspend_cleanup唤醒线程，然后调用_tx_semaphore_cleanup处理信号量超时事件
206 
207             /* Temporarily disable preemption.  */
208             _tx_thread_preempt_disable++; // 禁止抢占(_tx_thread_system_suspend会对_tx_thread_preempt_disable减1，调用_tx_thread_system_suspend前必须对_tx_thread_preempt_disable加1)
209 
210             /* Restore interrupts.  */
211             TX_RESTORE // 允许中断(之前对抢占计数器加1了，_tx_thread_system_suspend执行期间除了能处理中断服务程序外，其他线程是不允许被调度执行的，禁止抢占加上允许中断的目的只是避免阻塞中断并让_tx_thread_system_suspend执行完)
212 
213             /* Call actual thread suspension routine.  */
214             _tx_thread_system_suspend(thread_ptr); // 挂起当前线程
215 #endif
216 
217             /* Return the completion status.  */
218             status =  thread_ptr -> tx_thread_suspend_status; // 等待超时，清理函数会设置tx_thread_suspend_status为超时；别的线程释放信号量会释放给当前线程，tx_thread_suspend_status会设置为成功，当前线程被唤醒后，根据tx_thread_suspend_status即可知道自己是获取到了信号量还是超时了
219         }
220     }
221     else
222     {
223 
224         /* Restore interrupts.  */
225         TX_RESTORE
226 
227         /* Immediate return, return error completion.  */
228         status =  TX_NO_INSTANCE;
229     }
230 
231     /* Return completion status.  */
232     return(status);
233 }

至于等待信号量超时，在此略过，处理比较简单，与申请内存超时实现基本一样，可以参考：

ThreadX内核源码分析 - 动态内存管理_arm7star的博客-CSDN博客_threadx 内存管理

3、信号量释放_tx_semaphore_put

释放信号量操作也比较简单，主要是对计数信号量的计数器加1，然后检查是否有线程等待信号量，如果没有，对信号量计数器加1，直接返回即可，如果有等待信号量的线程，将信号量给等待链表第一个等待信号量的线程并唤醒该线程即可(不对信号量加1，直接把该信号量给等待线程，等待信号量的线程阻塞唤醒后不会再对信号量减1，可能有的内核会恢复信号量的值，然后唤醒所有等待信号量的线程，让等待信号量的线程去重新抢信号量，ThreadX内核没有这么做!!!)。

_tx_semaphore_put实现代码如下:

075 UINT  _tx_semaphore_put(TX_SEMAPHORE *semaphore_ptr)
076 {
077 
078 TX_INTERRUPT_SAVE_AREA
079 
080 #ifndef TX_DISABLE_NOTIFY_CALLBACKS
081 VOID            (*semaphore_put_notify)(struct TX_SEMAPHORE_STRUCT *notify_semaphore_ptr);
082 #endif
083 
084 TX_THREAD       *thread_ptr;
085 UINT            suspended_count;
086 TX_THREAD       *next_thread;
087 TX_THREAD       *previous_thread;
088 
089 
090     /* Disable interrupts to put an instance back to the semaphore.  */
091     TX_DISABLE // 关闭中断
092 
093 #ifdef TX_SEMAPHORE_ENABLE_PERFORMANCE_INFO
094 
095     /* Increment the total semaphore put counter.  */
096     _tx_semaphore_performance_put_count++;
097 
098     /* Increment the number of puts on this semaphore.  */
099     semaphore_ptr -> tx_semaphore_performance_put_count++;
100 #endif
101 
102     /* If trace is enabled, insert this event into the trace buffer.  */
103     TX_TRACE_IN_LINE_INSERT(TX_TRACE_SEMAPHORE_PUT, semaphore_ptr, semaphore_ptr -> tx_semaphore_count, semaphore_ptr -> tx_semaphore_suspended_count, TX_POINTER_TO_ULONG_CONVERT(&thread_ptr), TX_TRACE_SEMAPHORE_EVENTS)
104 
105     /* Log this kernel call.  */
106     TX_EL_SEMAPHORE_PUT_INSERT
107 
108     /* Pickup the number of suspended threads.  */
109     suspended_count =  semaphore_ptr -> tx_semaphore_suspended_count; // 等待信号量的线程数量
110 
111     /* Determine if there are any threads suspended on the semaphore.  */
112     if (suspended_count == TX_NO_SUSPENSIONS) // 没有线程等待信号量
113     {
114 
115         /* Increment the semaphore count.  */
116         semaphore_ptr -> tx_semaphore_count++; // 信号量计数器加1，恢复信号量计数器即可
117 
118 #ifndef TX_DISABLE_NOTIFY_CALLBACKS
119 
120         /* Pickup the application notify function.  */
121         semaphore_put_notify =  semaphore_ptr -> tx_semaphore_put_notify;
122 #endif
123 
124         /* Restore interrupts.  */
125         TX_RESTORE
126 
127 #ifndef TX_DISABLE_NOTIFY_CALLBACKS
128 
129         /* Determine if notification is required.  */
130         if (semaphore_put_notify != TX_NULL)
131         {
132 
133             /* Yes, call the appropriate notify callback function.  */
134             (semaphore_put_notify)(semaphore_ptr);
135         }
136 #endif
137     }
138     else // 有线程等待信号量(此次信号量计数器还没被修改，信号量还没释放)
139     {
140 
141         /* A thread is suspended on this semaphore.  */
142         
143         /* Pickup the pointer to the first suspended thread.  */
144         thread_ptr =  semaphore_ptr -> tx_semaphore_suspension_list; // 获取第一个等待信号量的线程(与互斥锁场景不同，继承优先级的互斥锁是让高优先级线程先获取到互斥锁，避免高优先级线程等待低优先级线程的情况)
145 
146         /* Remove the suspended thread from the list.  */
147 
148         /* See if this is the only suspended thread on the list.  */
149         suspended_count--; // 等待信号量的线程数量减1
150         if (suspended_count == TX_NO_SUSPENSIONS) // 如果没有其他线程等待信号量，那么情况信号量的等待链表即可
151         {
152 
153             /* Yes, the only suspended thread.  */
154 
155             /* Update the head pointer.  */
156             semaphore_ptr -> tx_semaphore_suspension_list =  TX_NULL;
157         }
158         else // 有其他线程等待信号量，第一个等待信号量的线程从等待链表删除即可(第一个等待信号量的线程thread_ptr即将获取到信号量)
159         {
160 
161             /* At least one more thread is on the same expiration list.  */
162 
163             /* Update the list head pointer.  */
164             next_thread =                                     thread_ptr -> tx_thread_suspended_next;
165             semaphore_ptr -> tx_semaphore_suspension_list =   next_thread;
166 
167             /* Update the links of the adjacent threads.  */
168             previous_thread =                               thread_ptr -> tx_thread_suspended_previous;
169             next_thread -> tx_thread_suspended_previous =   previous_thread;
170             previous_thread -> tx_thread_suspended_next =   next_thread;
171         }
172 
173         /* Decrement the suspension count.  */
174         semaphore_ptr -> tx_semaphore_suspended_count =  suspended_count; // 更新信号量等待线程个数(suspended_count在前面减1了，减thread_ptr)
175 
176         /* Prepare for resumption of the first thread.  */
177 
178         /* Clear cleanup routine to avoid timeout.  */
179         thread_ptr -> tx_thread_suspend_cleanup =  TX_NULL; // 清空thread_ptr的tx_thread_suspend_cleanup(thread_ptr获取到了信号量，不再需要清理函数)
180 
181 #ifndef TX_DISABLE_NOTIFY_CALLBACKS
182 
183         /* Pickup the application notify function.  */
184         semaphore_put_notify =  semaphore_ptr -> tx_semaphore_put_notify;
185 #endif
186 
187         /* Put return status into the thread control block.  */
188         thread_ptr -> tx_thread_suspend_status =  TX_SUCCESS; // thread_ptr获取到信号量，tx_thread_suspend_status设置为TX_SUCCESS，thread_ptr唤醒后会用tx_thread_suspend_status作为返回值，用于判断是否获取到信号量(如果超时，超时函数会设置tx_thread_suspend_status为超时状态，阻塞的线程唤醒后并不知道自己唤醒的原因，因此需要通过tx_thread_suspend_status来判断自己是怎么被唤醒的)
189 
190 #ifdef TX_NOT_INTERRUPTABLE
191 
192         /* Resume the thread!  */
193         _tx_thread_system_ni_resume(thread_ptr);
194 
195         /* Restore interrupts.  */
196         TX_RESTORE
197 #else
198 
199         /* Temporarily disable preemption.  */
200         _tx_thread_preempt_disable++; // 禁止抢占(_tx_thread_system_resume会对抢占计数器减1，这里必须加1)
201 
202         /* Restore interrupts.  */
203         TX_RESTORE // 允许中断
204 
205         /* Resume thread.  */
206         _tx_thread_system_resume(thread_ptr); // 唤醒thread_ptr(如果有抢占的话，会发生线程切换)
207 #endif
208 
209 #ifndef TX_DISABLE_NOTIFY_CALLBACKS
210 
211         /* Determine if notification is required.  */
212         if (semaphore_put_notify != TX_NULL)
213         {
214 
215             /* Yes, call the appropriate notify callback function.  */
216             (semaphore_put_notify)(semaphore_ptr);
217         }
218 #endif
219     }
220 
221     /* Return successful completion.  */
222     return(TX_SUCCESS);
223 }