Operating Systems Part 3 : Synchronization and Deadlock

Explore how critical sections access shared memory and trigger race conditions under preemption, causing inconsistent results. Learn how varying execution order produces different outcomes and why avoiding race conditions matters.

Explore how race conditions arise when multiple processes enter the critical section simultaneously, causing incorrect results, and learn how synchronization prevents simultaneous access to shared memory to ensure consistency.

Clarify the difference between critical and non-critical (reminder) sections, and explain why only one process may enter the critical section at a time, touching on race conditions and shared memory.

Explore synchronization mechanisms that prevent race conditions by using entry and exit sections around critical sections to ensure only one process accesses shared memory at a time.

Explore the concept of mutual exclusion for critical sections, and how synchronization mechanisms are judged by mutual exclusion, progress, and bounded waiting to prevent concurrent access.

Evaluate how progress ensures non-critical sections do not block others from entering the critical section, and how proper entry and exit sections define good synchronization.

Understand bounded waiting in synchronization by examining entry sections, while loops, and the critical section to prevent starving processes from waiting forever and bound how often they enter.

Explore the lock variable synchronization for multiple processes, using a boolean lock to guard the critical section, and the disadvantage that mutual exclusion may not be guaranteed.

Evaluate whether the lock variable satisfies progress, noting it does not satisfy mutual exclusion, and that only a process in the critical section may block others; therefore, progress is satisfied.

Analyze a lock variable to see if bounded waiting holds: it provides progress but fails mutual exclusion and bounded waiting, causing possible starvation as one process repeatedly enters critical sections.

Explore the lock synchronization mechanism, its advantages for multiple processes, and the distinction between busy and non-busy waiting through entry and exit sections.

Learn the basics of assembly code and how a test-and-set lock controls access to the critical section, explaining machine instructions, zero flags, and pre-emption issues.

Preemption during lock-based synchronization can violate mutual exclusion. Saving per-process register values and zero flags shows scheduler timing's impact on the critical section.

Explore the test and set lock (TSL) as an atomic instruction that prevents preemption between load and store, ensuring mutual exclusion during entry to the critical section, and discussing disadvantages.

Explain the TSL synchronization mechanism (test and set lock) that achieves mutual exclusion without preemption, its hardware dependent nature, and how initial and updated lock values control entry.

The TSL synchronization mechanism guarantees mutual exclusion and progress, but does not guarantee bounded waiting and is hardware dependent.

Explore the TSL synchronization mechanism as a busy-waiting solution for multiple processes, using entry and exit sections, and requiring hardware support unlike the lock variable.

Examine a TSL-based synchronization mechanism that uses a lock to control access to the critical section, revealing how initial lock values affect waiting and starvation behavior.

Analyze whether processes enter the critical section in first in, first out order, and discuss how entry section sequencing and starvation relate to fifo guarantees in synchronization.

Explore how mutual exclusion is guaranteed by a test-and-set mechanism without preemption, ensuring only one process in the critical section, and examine deadlock risks from circular waiting and scheduler behavior.

The strict alternation synchronization for two processes uses a turn variable with entry and exit sections to enforce mutual exclusion in the critical section, but progress is not guaranteed.

Explore strict alternation as a synchronization mechanism, showing that bounded waiting and mutual exclusion are guaranteed, but progress is not guaranteed.

Explore the strict alternation synchronization mechanism, a busy-waiting two-process solution using a turn variable to control entry to the critical section, with hardware independence and notable CPU waste.

The lecture analyzes a strict alternation-like synchronization with two booleans S1 and S2, where S1=S2 lets P2 enter and S1≠S2 lets P1 enter, proving mutual exclusion but not progress.

Explain disabling interrupts as a multi‑process synchronization mechanism, showing how it guarantees mutual exclusion but risks system halt due to misconfiguration, requiring hardware support for interrupt control.

Compare user mode with kernel mode and examine how disabling interrupts acts as a synchronization mechanism and its disadvantages in preventing preemption.

Master the interested synchronization mechanism using two boolean variables to ensure mutual exclusion in the critical section. Learn the entry and exit steps and the role of busy waiting.

Mutual exclusion is guaranteed by this mechanism. Each process checks whether the other process is inside the critical section before entering, preventing both from being inside at once.

Explore deadlock and circular waiting in synchronization mechanisms, illustrated by two processes P0 and P1 waiting on each other to enter the critical section.

Interested synchronization can lead to deadlock and thus fails to guarantee progress; when the critical section is free, only processes not in the non-critical section should decide which process enters.

Evaluate progress guarantees in a synchronization mechanism by confirming that a non-critical section cannot block others and that the decision for critical-section entry is not postponed indefinitely, avoiding deadlock.

Ensure bounded waiting by limiting how often other processes enter the critical section after a request; mutual exclusion is guaranteed, but deadlock remains a potential drawback.

Introduces the Peterson synchronization mechanism, a two-process busy waiting solution that uses interested flags and a turn variable to manage entry and exit from the critical section.

Explore the difference between local and global variables in C: local variables stay within a function, while global variables like turn are shared and overwritten across functions.

Peterson's synchronization mechanism coordinates two processes, P0 and P1, using interested flags and a turn variable to safely enter and exit the critical section.

Explore Peterson's synchronization mechanism for two processes, using interested flags and a turn variable to control entry to the critical section and handle preemption.

Peterson's synchronization guarantees mutual exclusion, allowing only one process at a time in the critical section while the other waits in the while loop.

Analyze the Peterson synchronization mechanism to show progress is guaranteed under all values of P0 and P1, by satisfying the first and second conditions for entering the critical section.

Peterson synchronization mechanism guarantees bounded waiting for entering the critical section, illustrated with processes P0 and P1 and the turn and interested flags.

Peterson's synchronization mechanism guarantees mutual exclusion, progress, and bounded waiting. Runs in user mode without system calls, stays platform independent and hardware-free, supports two processes, and uses busy waiting.