When two processes trying to access a resource is called race condition.
Main challenge is to avoid the race condition, the following method is usually adopted to avoid the race condition
- use of shared memory can prevent race condition
- Use of threads. Threads use the same address space when switching it to other threads(so same page directories and tables), whereas processes uses different address which leads to exchange of page directories and page tables. This is made with the help of POSIX Threads.
Forms of IPC
- Resource Sharing (system V Shared memory )
- Synchronization (Mutex, Semaphores)
- Connection oriented data exchange (Virtual Sockets, Pipes, named Pipes(FIFO))
- Connectionless data exchange (Signals)
Linux implements all forms of IPC
Synchronization in the Kernel
When multiple processors are used, how each processor is synchronized in the kernel is what described in this section.
Processor can acquire a spinlock whenever it wanted to access a resource.
volatile unsigned int lock; //default value is 1
- whenever a lock is wanted, it is set to 0 and during unlock it is set to 1
- the bus access to the other processors are blocked during the processing of this command (spinlock)
- if spinlock cannot be set, the processor waits in a loop until a lock variable is released again.
- single processor do not need spinlock
Other than spinlock, there is one more lock called the Read write lock
volatile unsigned int lock;
- The word count is declared with the type atomic_t indicates that the atomic means it does not leads to any race condition
- up() is a function which increments the count variable and wakes up all the sleeping processes when the count value is less than or equal to 0
- down() is the function which decrements the count variable, also increments the sleepers variable.
- the sum of sleepers and count is the correct value of the semaphore