1. Multiprocessors—Synchronization

2. Synchronization Why Synchronize? Need to know when it is safe for different processes to use shared data Issues for Synchronization: –Uninterruptable instruction to fetch and update memory (atomic operation); –User level synchronization operation using this primitive; –For large scale MPs, synchronization can be a bottleneck; techniques to reduce contention and latency of synchronization

3. Uninterruptable Instruction to Fetch and Update Memory Atomic exchange: interchange a value in a register for a value in memory 0 => synchronization variable is free 1 => synchronization variable is locked and unavailable –Set register to 1 & swap –New value in register determines success in getting lock 0 if you succeeded in setting the lock (you were first) 1 if other processor had already claimed access –Key is that exchange operation is indivisible Test-and-set: tests a value and sets it if the value passes the test Fetch-and-increment: it returns the value of a memory location and atomically increments it –0 => synchronization variable is free

4. Uninterruptable Instruction to Fetch and Update Memory Hard to have read & write in 1 instruction: use 2 instead Load linked (or load locked) + store conditional –Load linked returns the initial value –Store conditional returns 1 if it succeeds (no other store to same memory location since preceeding load) and 0 otherwise Example doing atomic swap with LL & SC: try:movR3,R4 ; mov exchange value llR2,0(R1); load linked scR3,0(R1); store beqzR3,try ; branch store fails movR4,R2 ; put load value in R4 Example doing fetch & increment with LL & SC: try:llR2,0(R1); load linked addiR2,R2,#1 ; increment (OK if reg–reg) scR2,0(R1) ; store beqzR2,try ; branch store fails

5. User Level Synchronization—Operation Using Swap Primitive Spin locks: processor continuously tries to acquire, spinning around a loop trying to get the lock liR2,#1 lockit:exchR2,0(R1) ;atomic exchange bnezR2,lockit ;already locked? What about MP with cache coherency? –Want to spin on cache copy to avoid full memory latency –Likely to get cache hits for such variables Problem: exchange includes a write, which invalidates all other copies; this generates considerable bus traffic Solution: start by simply repeatedly reading the variable; when it changes, then try exchange (“test and test&set”): try:liR2,#1 lockit:lwR3,0(R1) ;load var bnezR3,lockit ;not free=>spin exchR2,0(R1) ;atomic exchange bnezR2,try ;already locked?

6. Steps for Invalidate Protocol StepP0$P1$P2$Bus/Direct activity 1.Has lockShspinsShspinsShNone 2.Lock<– 0ExInvInvP0 Invalidates lock 3.ShmissShmissShWB P0; P2 gets bus 4.ShwaitsShlock = 0ShP2 cache filled 5.Shlock=0ShexchShP2 cache miss(WI) 6.InvexchInv return=0 ExP2 cache filled; Inv lock = 1 7. Inv return=1 ExlockedInvP1 cache miss;WB P2 lock = 1 8.InvspinsExInvNone

7. Simpler Lock Implementation lockit:llR2,0(R1);load linked bnezR2,lockit ;not free=>spin liR2,#1 ;locked value scR2,0(R1) ;store beqzR2,lockit ;branch if store fails

8. Barrier Synchronization A barrier forces all processes to wait unit all the processes reach the barrier and then releases all of the processes. Lock(countlock); If (count==0) release=0; Count++; Check = Count==total Unlock(countlock); If (Check) { count = 0; release = 1; } else { spin (release=1); }

9. Re-entering Barrier Switch is a private local variable initialized to 1. Switch = ! Switch Lock(countlock); Count++; Check = count==total; Unlock(countlock); If (Check) { count = 0; release = Switch; } else { spin (release=Switch); }