IPC@CHIP Documentation - SC12 @CHIP-RTOS V1.10

}
{
}
Surprised_to_be_Here() ; // How did this happen?
Figure 4 ) Protected Critical Section with Semaphore
Now the Surprised_to_be_Here() function will never be executed.
A potential disadvantage to using semaphores is a possible task priority inversion, where a high
priority task is blocked by a lower priority task as it awaits the semaphore. To illustrate this point,
consider an example where task priorities are designed as follows:
Task_A - Priority 60 (low priority)
Task_B - Priority 4 (very high priority)
If Task_A is suspended while it has possession of the semaphore, Task_B will have to wait if it then
tries to access the same semaphore at that moment. This wait is effectively at the very low priority 60,
which would mean that Task_B (priority 4) must sit waiting behind time consuming system activities
such as FTP transfer (priority 41). In applications where this potential priority inversion is not
acceptable, either the interrupt masking or task lock methods of protecting critical sections discussed
below can be considered as an alternative to using semaphores.
Interrupt Masking
Interrupt masking can in some cases be a safe alternative to using semaphores to protect critical
sections. This fast method places a minimum load on the system, so is most suitable where
performance is a concern. The interrupt masking method is used in the example below.
define MASK_INTERRUPTS asm{CLI}
#define ENABLE_INTERRUPTS asm{STI}
static unsigned long My_Ticker = 1 ;
void huge Task_A(void)
{
MASK_INTERRUPTS ; // Needed if Task_A is lower priority
if (My_Ticker < 0x7FFFFFFFL)
{
My_Ticker++ ;
}
ENABLE_INTERRUPTS ;
}
void huge Task_B(void)
{
unsigned long ticker ;
MASK_INTERRUPTS ; // Needed if Task_B is lower priority
ticker = My_Ticker ;
ENABLE_INTERRUPTS ;
if (ticker == 0)
{
Surprised_to_be_Here() ; // How did this happen?
Page 228 / 400