Causal Consistency Model in System Design

Causal Consistency is a consistency model in distributed systems that preserves the cause-and-effect relationship between operations. If one event influences another, all nodes in the system observe those events in the same causal order.

• Operations that are causally related are seen in the same order by all nodes, ensuring meaningful data updates.
• Provides a middle ground between strong consistency and eventual consistency, offering better performance while maintaining logical correctness.

Example: In a social media application, if User A posts a comment and User B replies to it, all users will see the original comment before the reply. This preserves the causal relationship between the two actions and prevents confusing event ordering.

Characteristics

Causal consistency maintains the logical order of related operations while allowing independent operations to execute concurrently, providing a balance between consistency and performance.

• Causal Relationship Preservation: Causal consistency ensures that events with a cause-and-effect relationship are observed in the same order by all nodes. This preserves the logical sequence of dependent operations across the system.
• Partial Ordering: Only causally related events must follow the same order. Events that are independent of each other may be observed in different orders by different nodes without violating consistency.
• Concurrency and Availability: Causal consistency allows multiple operations to execute concurrently when they are not causally related. This improves system performance and availability compared to stronger consistency models.
• Handling Delayed Messages: The model can handle delayed or out-of-order messages without breaking consistency. It ensures that causal dependencies are respected even when network delays occur.

Example

Let's consider a scenario where different processes( P1, P2, P3 and P4) try to do read/write operation on a variable x.

👁 Causal-consistency-copy

Scenario 1: Causally Related Operations

Process P1 writes value a to x. Process P2 then reads a from x and writes value b to x. Since P2's write depends on P1's write, these operations are causally related and must be observed in the same order by all processes.

• P3 reads a first and then b, which preserves the correct causal order.
• P4 reads b first and then a, which violates the causal order.

Result: The history observed by P4 is impossible in a causally consistent system, so this is a violation of causal consistency.

Scenario 2: Independent Operations

Processes P1 and P2 independently write values a and b to x without any causal relationship between them. Since neither operation depends on the other, they are considered concurrent.

• Different processes may observe these writes in different orders.
• There is no requirement for all nodes to see the same ordering of these independent operations.

Result: Different read orders are allowed, so there is no violation of causal consistency.

Causal Relationships in Distributed Systems

Causal relationships describe the cause-and-effect dependencies between events in a distributed system. Tracking these relationships ensures that related events are processed in the correct order across different nodes.

1. Lamport Clocks

Lamport clocks use logical timestamps to order events in a distributed system. When processes exchange messages, they update their timestamps to maintain a consistent event ordering.

2. Vector Clocks

Vector clocks use an array of timestamps to track causal dependencies between events. They provide a more accurate representation of event relationships than Lamport clocks by capturing the history of interactions between processes.

Real-World Example

One real-world example of causal consistency can be seen in a collaborative editing application like Google Docs. In Google Docs, multiple users can simultaneously edit a document. Each user's edits are sent to a central server and then broadcasted to other users' devices.

• Causal consistency ensures that the order of these edits is maintained based on their causal relationships.
• For example, if User A adds a sentence to the document and then User B adds another sentence based on the content added by User A, causal consistency guarantees that all users will see these edits in the correct order.
• This means that User B's sentence will always appear after User A's sentence, regardless of the order in which the edits are received by the server or other users' devices.

Without causal consistency, users may see edits in different orders on different devices, leading to confusion and inconsistent document views. Causal consistency preserves the correct order of related edits, ensuring a smooth and reliable collaboration experience.

Use-Cases and Applications

Causal consistency is widely used in distributed systems where preserving the order of related operations is important while still maintaining good performance and availability.

• Collaborative Editing: Applications such as Google Docs and Microsoft Office Online rely on causal consistency to ensure that edits made by different users are applied in the correct order. This allows all users to see a consistent and meaningful version of the document.
• Distributed Databases: Distributed databases use causal consistency to ensure that related updates are applied in the correct sequence across multiple nodes. This helps reduce conflicts and maintains a consistent view of the data.
• Distributed Systems Logging: Logging systems use causal consistency to record events according to their causal relationships. This provides a more accurate history of system activity for debugging and analysis.
• Event Sourcing: In event-sourced applications, the system state is reconstructed from a sequence of events. Causal consistency ensures that events are processed in the correct order, resulting in an accurate representation of the application state.

Implementation of Causal Consistency

The implementation code of Causal Consistency in C++ is:

Process 1: 1 
Process 2: 1 
Process 2: 1 Process 1: 1 
Process 1: 1 Process 2: 1 
Clock 1 happened before Clock 2: 1
Clock 2 happened before Clock 1: 1

Explanation of the above code

The code demonstrates how vector clocks can be used to track and compare causal relationships between events in a distributed system.

• VectorClock Class: Represents a vector clock used to track causal relationships between events in a distributed system. Each process maintains its own timestamp entry.
• update() Function: Increments the timestamp of a specific process, simulating an event occurring at that process.
• merge() Function: Combines two vector clocks when processes exchange messages, ensuring causal dependencies are synchronized.
• happenedBefore() Function: Compares two vector clocks to determine whether one event occurred before another based on their timestamps.
• main() Function: Creates and updates vector clocks, merges them, and checks the causal relationship between events using the vector clock mechanism.

Challenges

While causal consistency provides a balance between strong consistency and performance, it introduces several implementation and management challenges.

• Complexity: Tracking and maintaining causal dependencies between events can be difficult, especially in systems with many nodes and frequent updates.
• Concurrency Control: Managing concurrent updates requires additional coordination mechanisms, which can increase system complexity and affect performance.
• Scalability: As the number of nodes and updates grows, maintaining causal relationships across the system becomes more challenging.
• Performance Overhead: Techniques such as vector clocks and Lamport timestamps require extra metadata, which can increase storage, communication, and processing costs.
• Conflict Resolution: Concurrent updates to the same data may create conflicts, requiring effective resolution strategies to maintain a consistent system state.