The SWMR invariant reminds me a lot of reader-writer locks in Rust (and its analogues in other languages—I link to Rust specifically because it's in the standard library and the documentation is pretty). I'm curious if these sorts of concurrency notions came from hardware, software, or maybe a more abstract understanding of information from database theory.

These invariants strike me as being the exact same invariants required for managing a distributed database. I wonder how similar the two problems of implementing cache coherence and a distributed database are. I guess one difference is that the cache coherence solution is implemented in hardware, whereas the distributed database solution is in software?

This is probably obvious to most but this slide initially confused me because I thought the entire timeline was an epoch. However, each segment of the timeline is one epoch. The serialization comment makes much more sense when considering that the value that was read-write by P0 must be the same at the first bar and the second bar - and likewise for all other segments.

If we only had SWMR but didn't have write serialization, then in a later epoch, another processor might read a stale value that should have been updated according to the results of the last read-write epoch.

If we only had write serialization but didn't have SWMR, then within one epoch, multiple writers can conflict with each other, resulting in potentially incorrect results.