A before observing B. Conversely, two write operations C and D are said concurrent, or causally independent, if neither causally precedes the other. In this case, a process may observe either C before D, or D before C. The Causal Precedence relation in shared memory is related to the happened-before relation in message-based communication. Thus, a system provides causal consistency if this following condition holds: write operations that are related by potential causality are seen by each process of the system in their causal precedence order. Different processes may observe concurrent writes in different orders. The Causal Consistency model is weaker than sequential consistency, which ensures that all processes observe all write operations in common order, whether causally related or not. However, causal consistency is stronger than PRAM consistency, which requires only the write operations that are done by a single process to be observed in common order by each other process. It follows that when a system is sequentially consistent, it is also causally consistent. Additionally, causal consistency implies PRAM consistency, but not vice versa. Example Here is an example of causal consistency. Causal relations are respected in the following event sequence: Process P2 observes, reads, the earlier write W(x)1 that is done by process P1. Therefore, the two writes W(x)1 and W(x)2 are causally related. Under causal consistency, every process observes W(x)1 first, before observing W(x)2. Notice that the two write operations W(x)2 and W(x)3, with no intervening read operations, are concurrent, and processes P3 and P4 observe (read) them in different orders. Session Guarantees The causal consistency model can be refined into four session guarantees.. They can be summarised as follows: Read Your Writes: If a process performs a write, the same process later observes the result of its write. Monotonic Reads: the set of writes observed (read) by a process is guaranteed to be monotonically non-decreasing. Writes Follow Reads: if some process performs a read followed by a write, and another process observes the result of the write, then it can also observe the read (unless it has been overwritten). Monotonic Writes: If some process performs a write, followed some time later by another write, other processes will observe them in the same order. Transactional session guarantees for serialisability and snapshot isolation are presented by Daudjee and Salem. Implementation The system is abstracted as a set of communicating processes. When a process writes into the shared