1.5 Synchronization, cpu scheduling

Race conditions

A race condition occurs when two (or more) processes are about to perform some action. Depending on the exacttiming, one or other goes first. If one of the processes goes first, everything works, but if another one goes first, an error, possibly fatal, occurs.

Imagine two processes both accessing x, which is initially 10.

• One process is to execute x x+1
• The other is to execute x x-1
• When both are finished x should be 10
• But we might get 9 and might get 11!
• Show how this can happen (x x+1 is not atomic)
• Tanenbaum shows how this can lead to disaster for a printer spooler

Critical sections

We must prevent interleaving sections of code that need to be atomic with respect to each other. That is, the conflicting sectionsneed mutual exclusion . If process A is executing its critical section, it excludes process B from executing its critical section.Conversely if process B is executing is critical section, it excludes process A from executing its critical section.

Requirements for a critical section implementation.

1. No two processes may be simultaneously inside their critical section.
2. No assumption may be made about the speeds or the number of CPUs.
3. No process outside its critical section (including the entry and exit code)may block other processes.
4. No process should have to wait forever to enter its critical section.
   • I do NOT make this last requirement.
   • I just require that the system as a whole make progress (so not all processes are blocked).
   • I refer to solutions that do not satisfy Tanenbaum's last condition as unfair, but nonetheless correct, solutions.
   • Stronger fairness conditions have also been defined.

Mutual exclusion with busy waiting

The operating system can choose not to preempt itself. That is, we do not preempt system processes (if the OS is client server)or processes running in system mode (if the OS is self service). Forbidding preemption for system processes would prevent the problem above where x x+1 notbeing atomic crashed the printer spooler if the spooler is part of the OS.

But simply forbidding preemption while in system mode is not sufficient.

• Does not work for user-mode programs. So the Unix print spooler would not be helped.
• Does not prevent conflicts between the main line OS and interrupt handlers.
  • This conflict could be prevented by disabling interrupts while the main line is in its critical section.
  • Indeed, disabling (a.k.a. temporarily preventing) interrupts is often done for exactly this reason.
  • Do not want to block interrupts for too long or the system will seem unresponsive.

Does not work if the system has several processors.

• Both main lines can conflict.
• One processor cannot block interrupts on the other.

Software solutions for two processes

Initially P1wants=P2wants=false

Code for P1 Code for P2

Loop forever { Loop forever {

P1wants = true ENTRY P2wants = true

while (P2wants) {} ENTRY while (P1wants) {}

critical-section critical-section

P1wants = false EXIT P2wants = false

non-critical-section } non-critical-section }