Understanding Critical Section Problem in Operating Systems

1. Critical Section Problem CIS 450 Winter 2003 Professor Jinhua Guo

2. Thread Control Block • OS’s representation of thread • Registers, PC, SP, scheduling info, etc • Several different lists of TCBs in OS • Ready list • Blocked lists • Waiting for disks • Waiting for input • Waiting for events

3. Context Switching • Switching between 2 threads • Change PC to current instruction of new thread • might need to run old thread in the future • Must save exact state of first thread • State saved into the TCB • What must be saved? • Registers (including PC and SP) • What about stack itself?

4. Implementing Threads in User Space A user-level threads package

5. Implementing Threads in the Kernel A threads package managed by the kernel

6. Hybrid Implementations Multiplexing user-level threads onto kernel- level threads

7. Independent vs. Cooperating Threads • Independent threads • No state shared – separate address space • Cooperating threads • Same address space • Can affect one another • Must be careful!

8. Example of Concurrent Program int balance = 100; void deposit (int amount) { balance += amount; exit(0); } int main () { threadCreate(deposit, 10); threadCreate(deposit, 20); waitForAllDone(); /*make sure all children finish*/ printf (“The balance is %d”, balance); } What are the possible output?

9. insert (head, elem) { Elem->next := head; head := elem; } void *removed (head) { void *tmp; tmp := head; head := head->next; return t; } More Concurrent Programming: Linked lists (head is shared) Assume one thread calls insert and one calls remove.

10. Race Condition • This kind of bug, which only occurs under certain timing conditions, is called a race condition. • Output depends on ordering of thread execution • More concretely: • two or more threads access a shared variable with no synchronization, and • at least one of the threads writes to the variable

11. Critical Section • Section of code that: • Must be executed by one thread at a time • If more than one thread executes at a time, have a race condition • Ex: linked list from before • Insert/Delete code forms a critical section • What about just the Insert or Delete code?

12. Critical Section (CS) Problem • Provide entry and exit routines • All threads must call entry before executing CS. • All threads must call exit after executing CS • Thread must not leave entry rounte until it’s safe.

13. Structure of threads for Critical Section Problem • Threads do the following While (1) { call entry(); critical section call exit(); do other stuff; }

14. Properties of Critical Section Solution • Mutual Exclusion: at most one thread is executing CS. • Absence of Deadlock: two or more threads trying to get into CS => at least one succeeds. • Absence of Unnecessary Delay: if only one thread trying to get into CS, it succeeds • Bounded Waiting: thread eventually gets into CS.

15. Critical Section Solution Attempt #1(2 thread solution) Intially, turn == 0 entry (id) { while (turn !=id); /* if not my turn, spin */ } exit(id) { turn = 1 - id; /* other thread’s turn*/ }

16. Critical Section Solution Attempt #2(2 thread solution) Intially, flag[0] == flags[1] == false entry (id) { flag [id] = true; /* I want to go in */ while (flag[1-id]); /* proceed if other not trying */ } exit(id) { flag[id] = false; /* I am out*/ }

17. Critical Section Solution Attempt #3(2 thread solution) Intially, flag[0] == flags[1] == false, turn entry (id) { flag [id] = true; /* I want to go in */ turn = 1 – id; while (flag[1-id] && turn == 1-id); /* proceed if other not trying */ } exit(id) { flag[id] = false; /* I am out*/ }

18. Satisfying the 4 properties • Mutual exclusion • turn must be 0 or 1 => only one thread can be in CS • Absence of deadlock • turn must be 0 or 1 => one thread will be allowed in • Absence of unnecessary delay • only one thread trying to get into CS => flag[other] is false => will get in • Bounded Waiting • spinning thread will not modify turn • thread trying to go back in will set turn equal to spinning thread

19. Critical Section Problemmultiple threads solutions • Bakery algorithm • It’s a mess • Trying to prove it correct is a headache

20. Hardware Support • Provide instruction that is: • Atomic • Fairly easy for hardware designer to implement • Read/Modify/Write • Atomically read value from memory, modify it in some way, write it back to memory • Use to develop simpler critical section solution for any number of threads.

21. Atomic Operation • An operation that, once started, runs to completion • Indivisible • Ex: loads and stores • Meaning: if thread A stores “1” into variable x and thread B stores “2” into variable x about the same time, result is either “1” or “2”.

22. Test-and-Set • Many machines have it bool TestAndSet(bool &target) { bool b = target; target = true; return b; } • Executes atomically

23. CS solution with Test-and-Set Initially, s == false; entry () { bool spin; spin = TestAndSet(s); while (spin) spin = TS(s); } exit() { S = false; }

24. Basic Idea With Atomic Instructions • Each thread has a local flag • One variable shared by all threads • Use the atomic instruction with flag, shared variable • on a change, all thread to go in • Other threads will not see this change • When done with CS, set shared varible back to initial state.

25. Other Atomic Instructions The definition of the Swap instruction void Swap(bool &a, bool &b) { bool temp = a; a = b; b = temp; }

26. Problems with busy-waiting CS solution • Complicated • Inefficient • Consumes CPU cycles while spinning • Priority inversion problem • Low priority thread in CS, high priority thread spinning can end up causing deadlock Solution: block when waiting for CS