/
lectern.tv
Play15s30s1x0:00/--:--
DoneWatched
Expand
lectern.tv
1:07:24/1:20:10
5:59
3:29
2:13
2:55
4:39
2:20
7:36
4:10
1:05
6:43
1:41
3:15
3:41
4:05
2:39
5:56
2:10
1:10
2:25
0:41
1:40
5:35
2:55
Synchronization Without Locks
Master non-lock synchronization, memory models, Peterson's algorithm, and lock-free programming with MIT's Charles Leiserson.
Lecture guide · Written by AI from the lecture. For the lecture’s own words, open the Transcript tab.
Charles Leiserson covers non-lock synchronization methods and hardware memory models in parallel computing systems. He analyzes sequential consistency, instruction reordering, store buffers, and Peterson's algorithm for mutual exclusion, before demonstrating how compare-and-swap operations enable lock-free programming.
This lecture assumes
- Threadstaught in Introduction & MapReduce at 21:47
Key Takeaways
- Sequential consistency provides a foundational, theoretical model for parallel execution where operations appear to follow a single global linear order.
- No modern computer implements strict sequential consistency due to hardware and compiler optimizations that reorder instructions for performance.
- Store buffers and load bypass mechanisms allow modern processors to speed up memory operations, which can violate sequential execution assumptions.
- Peterson's algorithm achieves mutual exclusion using only ordinary load and store operations under a sequentially consistent memory model.
Concepts Explained18
Memory Model—A memory model defines how memory operations behave and how memory updates are ordered and observed across multiple processors in a parallel computer system.
Sequential Consistency—Sequential consistency requires that the result of any parallel execution is the same as if all processors' operations were executed in some single sequential order respecting each processor's individual program order.
Happens-before relation—A strict partial ordering of events in a concurrent system that defines causal precedence between operations.
Critical Section—A piece of code that accesses a shared data structure that must not be accessed by two or more threads at the same time.
Examples, Proofs & Derivations