Process Synchronization I CPE Operating Systems

Why do we need to Synchronize?

Problem Example A simple C primitive: Count++ Actual machine code: Register1 = count Increase register1 Count = register1

Problem Example Register1 = count Increase register1 Count = register1 Register2 = count Increase register2 Count = register2 Register1 = count Register2 = count Increase register2 Count = register2 Increase register1 Count = register1

Critical Section Code where multiple processes (threads) can write to a shared location or acquire a shared resource. Need some form of Synchronization!

Software Solution? Assuming only two processes turn = p1; While (turn == p2) {/* busy wait */}; turn = p2; //Critical Section Count++; turn = p2; While (turn == p1) {/* busy wait */}; turn = p1; //Critical Section Count++; P1P2 (There are still problematic cases)

Software Solution? Peterson’s Solution turn = p2; p1_needs_to_work = true; While (turn == p2 && p2_needs_to_work) {/* busy wait */}; p1_needs_to_work = false; //Critical Section Count++; turn = p1; p2_needs_to_work = true; While (turn == p1 && p1_needs_to_work) {/* busy wait */}; p2_needs_to_work = false; //Critical Section Count++; P1P2

Synchronization Hardware Special atomic hardware instructions

Test-and-Set Instruction Equivalent to: boolean testAndSet(boolean *Lock) { boolean originalVal = *Lock; *Lock = true; return originalVal; }

Test-And-Set Applies to any N processes While (testAndSet(&Lock)) { /* busy wait */ }; Lock = false; //Critical Section Count++; While (testAndSet(&Lock)) { /* busy wait */ }; Lock = false; //Critical Section Count++; P1P2

Requirements for solving the Critical Section Problem Mutual Exclusion Progress Bounded Waiting

Semaphores

Semaphore as a Signaling Tool

Semaphore as a Communication Tool

ROGER

Nuclear Disarmamenthttp:// Semaphore in Pop Culture

Types of Semaphores Critical section tool (Mutex Lock) Counting Semaphore

Mutex Lock Wait(S); Signal(S); //Critical Section Count++; Wait(S); Signal(S); //Critical Section Count++; P1P2 Semaphore S;

Counting Semaphore Wait(S); Signal(S); // Access Shared // resources P1 Semaphore S = 3; Database P1

Semaphore Implementation Wait (S) { S.value--; if (S.value < 0) { sleep(); } Signal (S){ S.value++; if (S.value <= 0) { wakeupSleepingProcesses(); }

Semaphore’s Application Critical Section Tool Resource Usage Control (limiting usage) Synchronizing threads

Semaphore Example I: Resource Usage Control Database Manager P1 Limit 2 connections P2 PnPn …

Wait(Database); // make DB connection // and get the data Signal(Database); Database Manager P1 P2 PnPn … P Semaphore Database = 2

Semaphore Example II: Process Synchronization P3: Database Manager P1: Client P2: Server Request DB Connection DB DataResponse P2 limits 10 connection P3 limits 2 connections

P3: Database Manager P1: Client P2: Server RequestDB Connection DB DataResponse Semaphore Client = 0, Server = 10, Database = 2, DBData = 0 Wait(server); Signal(Client); Wait(DBData); // receives the data Signal(server); While (true) { Wait(Client); Wait(Database); // make DB connection // and get the data Signal(Database); Signal(DBData); } ClientServer

The Dim sum Restaurant

Steamers Waiter Restaurant Waiter

Semaphore Seats=6; Customer=0; Waiter=2; Steamer=3; Food=1; CustomerWaiter

While (true) { Wait (Customer) Signal (Waiter) // gets the order Wait (Steamer) // food is cooked Signal (Steamer) Signal (Food) } Wait(Seats) Signal(Customer) Wait(Waiter) /// Places order Wait(Food) /// Eat the food Signal(Seats) Semaphore Seats=6; Customer=0; Waiter=1; Steamer=3; Food=0; CustomerWaiter