GATE CSE 1990 | Question: 1-vii

Question

Semaphore operations are atomic because they are implemented within the OS _________.

Comments

Semaphores are lock variables with sleeping mutex hence they are atomic in nature

---

can somebody explain the question

Answer 1

The concept of semaphores is used for synchronization.
Semaphore is an integer with a difference. Well, actually a few differences.
You set the value of the integer when you create it, but can never access the value directly after that; you must use one of the semaphore functions to adjust it, and you cannot ask for the current value.
There are semaphore functions to increment or decrement the value of the integer by one.
Decrementing is a (possibly) blocking function. If the resulting semaphore value is negative, the calling thread or process is blocked, and cannot continue until some other thread or process increments it.
Incrementing the semaphore when it is negative causes one (and only one) of the threads blocked by this semaphore to become unblocked and runnable.

Therefore, all semaphore operations are atomic. Implemented in kernel,

Comments

@Pratik Gawali

Yes, processes running in user mode can be preempted but processes running in kernel mode can not be preempted.

 

 

---

Semaphore operations are atomic because they are implemented with atomic hardware instructions or synchronized using operating system mechanisms like locks or atomic operations. These mechanisms ensure that semaphore operations, such as wait (P) and signal (V), are indivisible and cannot be interrupted by other processes or threads, thereby maintaining consistency and preventing race conditions. So, while the operating system plays a role in managing concurrency and providing synchronization primitives, the atomicity of semaphore operations stems from low-level hardware support or operating system synchronization mechanisms.

---

No, not all operations in the kernel are atomic. While certain operations in the kernel may be implemented atomically to prevent race conditions and ensure consistency, not all operations are guaranteed to be atomic.

Regarding system calls, they can be preempted, but the kernel often takes measures to ensure that critical sections of code, such as those involving shared resources or synchronization primitives like semaphores, are executed atomically. This is typically achieved through disabling interrupts or using locking mechanisms to prevent preemption while critical operations are being performed. However, this doesn't mean that all system calls are atomic or cannot be preempted. It depends on the specific implementation and requirements of the kernel and the operations being performed.