Process Communication and Synchronization

What is the critical-section problem? Why must executing the critical section be mutually exclusive? Describe how semaphores can solve the critical-section problem.

A critical section is a part of a program that accesses a shared resource, such as memory, a data structure, the CPU, or an I/O resource. More than one process must not execute the critical section at the same time. Processes need a protocol for entering and leaving it so that concurrent changes do not cause a race condition.

Mutual exclusion prevents a second process from entering while the first is inside. Otherwise, changes made by one process can cause errors in another. A semaphore controls entry through wait and releases access through signal. The original pseudocode and accompanying explanation are retained below.

The handwritten explanation repeats process labels in a confusing way. Refer to the original rather than treating those labels as corrected here.

What is a race condition? Why are sleep() and wakeup() better than busy waiting?

A race condition occurs when processes read or write shared data and the final result depends on which process runs when. Busy waiting continually checks a condition, wasting CPU time. With priority scheduling, it can also cause progress problems when the waiting process prevents the process that must release the resource from running. sleep() suspends a process; another process calls wakeup() when it can proceed.

What is TSL? Why is it used? Explain the major operations of a semaphore with a simple implementation as a class.

TSL means test-and-set lock. It provides synchronization for mutual exclusion. The semaphore operations are wait, used before accessing a resource, and signal, used when the process finishes using it. The source's class implementation is preserved below, including its original notation and incomplete code details.

Explain the critical-section problem. Why is it important for a thread to execute its critical section as quickly as possible?

Only one thread may hold the lock and execute the critical section at a time. Other threads must wait until it releases the lock. Finishing quickly lets those threads proceed sooner. The critical-section definition is given in Question 1.

Define a semaphore and explain its major operations, including pseudocode.

A semaphore is a variable used to solve critical-section and synchronization problems in multiprocessing. The two major operations are wait and signal. Their exact handwritten pseudocode is retained below:

State the requirements for mutual exclusion. Solve the producer–consumer problem using semaphores and message passing.

1. No two processes may be inside their critical sections simultaneously.
2. No assumptions should be made about processor speeds or the number of CPUs.
3. A process outside its critical section must not block another process.
4. No process should wait forever to enter its critical section.

The semaphore solution is reproduced below. The source does not supply the requested message-passing solution.

Solve the producer–consumer problem using monitors.

The critical operations belong inside a ProducerConsumer monitor, which provides mutual exclusion. A producer or consumer that cannot continue waits on a condition; another operation signals that condition when progress becomes possible. The source uses an item count and conditions for full and empty states. Its partial first attempt and subsequent monitor implementation are both preserved.

Why is synchronization needed? Explain Peterson's solution and TSL as busy-waiting solutions.

Synchronization coordinates processes using shared resources so that concurrent operations do not leave inconsistent data. Peterson's solution coordinates two processes accessing a shared resource. Each calls enter_region before its critical section and leave_region afterward; entry waits until it is safe to proceed.

TSL copies the old lock value into a register and sets the lock atomically. The process compares the old value with zero and repeats if the lock was already held. On leaving the critical section it releases the lock. The original code and explanations follow.

One source sentence says the lock is set back to 1, while the exit code and later explanation use 0. The inconsistency is retained in the scan.

Why are pipes needed? Define a semaphore and its operations. Can semaphores be used in a distributed system?

A pipe passes the output of one process to the input of another. The source describes communication between related processes, such as parent and child processes. Semaphore definitions and operations are given in Question 5.

The source says that distributed processors do not share memory and communicate by messages. It then discusses indirectly implementing semaphore-like coordination using message passing.

Source ambiguity: The answer first denies the use of semaphores in distributed systems and later describes a message-based implementation. It does not clearly distinguish a shared-memory semaphore from distributed emulation.

Explain approaches that prevent another process from entering its critical section while shared memory is being updated.

• Disable interrupts: On a single CPU, preventing interrupts stops a process from being switched out during the critical section. Giving user processes this power is unattractive.
• Lock variable: A shared variable indicates whether the critical section is free or occupied. The source presents the 0/1 approach without establishing that the check-and-set operation is atomic.
• Strict alternation: A shared turn variable selects which process may enter. The other process busy-waits until the turn changes.
• Peterson's solution: Coordinates two processes through shared state; see Question 8.
• TSL: Atomically reads the old lock value and sets the lock; only the process that finds it free enters.

The strict-alternation code and remaining original discussion are preserved below.