Chapter II

Time and Global States:

 Synchronization in Distributed Systems

Synchronization in distributed systems is a critical aspect that ensures the consistent and coordinated
operation of multiple processes or nodes across a network. It involves various techniques to maintain
data consistency, manage concurrent access to shared resources, and achieve coherent system
behavior.
Key Challenges and Goals:
•Data Consistency: Ensuring that multiple copies of data remain consistent across different nodes.
•Concurrent Access: Managing simultaneous access to shared resources to prevent conflicts and data
corruption.
•Process Coordination: Coordinating the execution of processes to achieve a desired system
behavior.
•Fault Tolerance: Handling failures and ensuring that the system can recover and maintain consistency.
Types of Synchronization:
1.Time Synchronization:
•Ensures that all nodes in the system have a consistent view of time.
•Crucial for coordinating events, logging, and maintaining consistency in distributed applications.
•Algorithms:
•Network Time Protocol (NTP): Widely used for synchronizing clocks across the internet.
•Precision Time Protocol (PTP): Used for high-precision time synchronization in networks.
2.Data Synchronization:
•Maintains consistency between multiple copies of data across different nodes.
•Techniques:
•Replication: Creating multiple copies of data on different nodes.
•Distributed Locking: Using locks to control access to shared data.
•Optimistic Concurrency Control (OCC): Assuming that conflicts are rare and handling them when
they occur.
•Pessimistic Concurrency Control (PCC): Preventing conflicts by locking resources before
accessing them.
3.Process Synchronization:
•Coordinates the execution of processes to ensure they operate correctly without conflicts.
•Mechanisms:
•Mutual Exclusion: Ensuring that only one process can access a shared resource at a time.
•Semaphores: A synchronization primitive that can be used to control access to shared
resources.
•Monitors: A high-level synchronization construct that encapsulates shared data and the operations
that can be performed on it
 Common Synchronization Algorithms:

1.Lamport's Logical Clocks: A method for ordering events in a distributed system without relying on physical
clocks. Each event is assigned a timestamp, and the clocks are synchronized by passing these timestamps
between processes.
2.Vector Clocks: An extension of Lamport's clocks that provides partial ordering of events and can determine the
causal relationship between them.
3.Physical Clock Synchronization: Techniques like the Network Time Protocol (NTP) and Precision Time
Protocol (PTP) are used to synchronize physical clocks across a network.
4.Mutual Exclusion Algorithms: Algorithms like Ricart-Agrawala and Lamport's bakery algorithm ensure that
only one process can access a critical section at a time.
5.Token Ring Algorithm: A method where a token is passed around the network, and only the holder of the
token can perform certain actions, ensuring synchronized access to resources.
6.Election Algorithms: Algorithms like Bully and Ring algorithms are used to elect a coordinator or leader among
distributed processes.
These algorithms help maintain consistency and coordination in distributed systems, ensuring that all
components work together seamlessly
Synchronization is crucial in distributed systems for several reasons:
1. Data Consistency:
•Preventing Data Corruption: Multiple nodes might access and modify the same data concurrently. Without synchronization, this
can lead to race conditions and data inconsistencies.
•Maintaining Data Integrity: Synchronization ensures that data remains consistent across different nodes, even in the presence
of updates and modifications.
2. Process Coordinatioan:
•Ensuring Correct Execution: Synchronization mechanisms coordinate the execution of processes to prevent conflicts and
ensure that they operate correctly.
•Achieving Desired System Behavior: Synchronization allows processes to collaborate and achieve a specific system goal,
such as a distributed transaction or a distributed algorithm.
3. Fault Tolerance:
•Handling Failures: Synchronization mechanisms can help a distributed system recover from failures by ensuring that data
remains consistent and processes can be restarted correctly.
4. Resource Management:
•Fair Resource Allocation: Synchronization can be used to allocate shared resources fairly among different processes or
nodes.
•Preventing Deadlocks: Synchronization mechanisms can help prevent deadlocks, which occur when processes are waiting for
each other to release resources.
5. Scalability:
•Handling Increased Load: Synchronization techniques can help distribute the workload across multiple nodes, improving the
scalability of the system.
In Summary:
Synchronization is essential in distributed systems to ensure data consistency, process coordination, fault tolerance, resource
management, and scalability.
By effectively synchronizing the activities of different nodes, distributed systems can operate reliably, efficiently, and maintain data
integrity
Synchironization in centralized and distributed system

Synchronization in Centralized vs. Distributed Systems

Synchronization is a fundamental concept in both centralized and distributed systems, ensuring the coordinated execution
of processes and data consistency. However, the mechanisms and complexities involved differ significantly between the
two.
Centralized Systems
In a centralized system, a single server or process controls and manages all operations. Synchronization is relatively
straightforward due to the centralized control:
•Shared Memory: Processes can directly access and modify shared memory locations.
•Operating System Kernels: These provide synchronization primitives like semaphores, mutexes, and condition variables
to regulate access to shared resources.
•Simple Coordination: The central authority can easily coordinate the activities of different processes.
Distributed Systems
Distributed systems, on the other hand, involve multiple nodes or processes that communicate and coordinate with each
other over a network.

Synchronization in this context becomes more challenging due to factors like:

•Network Latency: Communication delays can introduce uncertainties and complexities.
•Partial Failures: Individual nodes or network links may fail, affecting the overall system's behavior.
•Lack of Shared Memory: Processes on different nodes cannot directly access the same memory locations.
In the context of distributed systems (DS), the term "clock" can refer to two main concepts:
1. Physical Clocks:
• Hardware Clocks: These are the actual physical clocks present in each node of the distributed
system. They use physical oscillators to measure time.
• Synchronization: Algorithms like NTP (Network Time Protocol) are used to synchronize these
physical clocks across the network, ensuring a relatively consistent time reference among
different nodes.
2. Logical Clocks:
• Lamport Clocks: These are virtual clocks that assign unique timestamps to events in a distributed
system, ensuring a partial ordering of events based on causality. They don't rely on physical time
but rather on the sequence of events.
• Vector Clocks: These are more sophisticated logical clocks that track the history of events at each
node. They provide a more precise ordering of events, especially when dealing with concurrent
events.
Both types of clocks play crucial roles in distributed systems:
• Physical Clocks: They are essential for tasks that require accurate real-time measurements, such
as timing critical operations, scheduling tasks, and synchronizing distributed protocols.
• Logical Clocks: They are used to order events in a distributed system, even in the absence of a
global clock. This is important for tasks like debugging, distributed garbage collection, and
distributed consensus algorithms.
By understanding the concepts of physical and logical clocks, we can design and analyze distributed
systems that are efficient, reliable, and fault-tolerant.
 Clocks, Events, and Process States in Distributed Systems

In a distributed system, where multiple computers communicate and collaborate over a network, understanding the concepts
of clocks, events, and process states is crucial.
Clocks
In a distributed system, each computer has its own clock. However, these clocks are not perfectly synchronized. This leads to
several challenges:
Clock Drift vs. Clock Skew
In distributed systems, accurate timekeeping is crucial for various operations, such as timestamping events, coordinating
actions, and ensuring consistency. However, due to hardware imperfections and environmental factors, clocks in different
systems can diverge over time, leading to clock drift and skew.
Clock Drift This refers to the gradual divergence of a clock's rate from a reference clock. It occurs due to variations in the
oscillator frequency of the clock's hardware. This means that one clock might run slightly faster or slower than another,
causing a gradual time difference.
Clock Skew Clock skew is the difference in time between two clocks at a specific point in time. It can be caused by various
factors, including initial time differences, clock drift, and network delays.

Events
An event is a significant occurrence in a process's execution. It can be a message send, a message receive, or a change in
the process's state.
Clock drift
• refers to the gradual divergence of a clock's time from a reference time standard. This
occurs due to variations in the clock's frequency and environmental factors.
• In simpler terms, it's like two watches that start at the same time, but one runs slightly
faster or slower than the other, causing them to gradually show different times.
• This phenomenon is particularly significant in distributed systems where multiple
computers need to coordinate their actions based on time. If their clocks are not
synchronized, it can lead to inconsistencies, errors, and even system failures.
To address clock drift, various synchronization techniques are employed, such as:
• Network Time Protocol (NTP): This protocol synchronizes clocks across a network by
periodically adjusting their time.
• Precision Time Protocol (PTP): This protocol provides more accurate time
synchronization, especially for real-time applications.
By using these techniques, distributed systems can maintain accurate time across all nodes,
ensuring smooth operation and preventing potential issues.
 Impact of Clock Drift and Skew:
•Inaccurate Timestamps: Events may be incorrectly ordered or assigned incorrect timestamps.
•Coordination Problems: Distributed systems may experience difficulties in coordinating actions due to inconsistent time.
•Security Vulnerabilities: Cryptographic protocols and security mechanisms may be compromised if time is not synchronized.

Mitigation Techniques:
To mitigate the effects of clock drift and skew, various techniques are employed:
•Network Time Protocol (NTP): NTP is a widely used protocol for synchronizing clocks across a network. It uses a
hierarchical architecture to distribute time from reliable time sources.
•Precision Time Protocol (PTP): PTP is a more precise protocol that is often used in critical real-time systems. It offers
lower latency and higher accuracy than NTP.
•Hardware-Based Time Synchronization: Some systems use hardware-based time synchronization mechanisms, such
as GPS receivers or atomic clocks, to achieve high accuracy.
By understanding and addressing clock drift and skew, we can ensure the reliable operation of distributed systems.
 Lamport's Logical Clocks
• Lamport's logical clocks are a mechanism used in distributed systems to provide a partial ordering of events, even in the absence of a global clock. This is crucial for tasks like
synchronization, causal ordering, and conflict resolution.
• Partial Ordering:
1. If event A happens before event B on the same process, then the timestamp of A is less than the timestamp of B.
2. If event A (sending a message) happens before event B (receiving the message), then the timestamp of A is less than the timestamp of B.
Lamport's Algorithm: A Distributed Mutual Exclusion Protocol
Lamport's algorithm is a distributed mutual exclusion algorithm that ensures only one process can access a shared resource at a time in a distributed system. It achieves
this by using logical clocks to assign timestamps to events and by using a request-reply mechanism to coordinate access to the critical section.
Here's how it works:
1.Logical Clocks:
•Each process maintains its own logical clock.
•Whenever a process generates an event (e.g., sending a message, entering the critical section), it increments its clock.
•Timestamps are assigned to events based on their causal order.
2.Requesting the Critical Section:
•A process that wants to enter the critical section generates a timestamped request message.
•It sends this request to all other processes.
3.Receiving Requests:
•When a process receives a request, it compares the timestamp of the received request with its own local clock.
•If the received timestamp is larger, it updates its local clock to the larger value.
•It then places the request in its local queue, ordered by timestamp.
4.Entering the Critical Section:
•A process can enter the critical section only if:
•It has received a message with a larger timestamp from all other processes.
•Its own request is at the head of its local queue.
5.Releasing the Critical Section:
•After exiting the critical section, the process removes its request from its local queue.
•It sends a release message to all other processes.
Applications:
•Distributed Synchronization:
•Ensuring that certain operations occur in a specific order, like committing transactions in a
distributed database.
•Conflict Resolution:
•Detecting and resolving conflicts in replicated data, such as in distributed file systems.
•Distributed Debugging:
•Analyzing the execution of distributed systems by ordering events and identifying causal
relationships.
Example:
Consider two processes, P1 and P2.
P1:
Event 1: Timestamp 1
Event 2: Timestamp 2
P2:
Event 3: Timestamp 3
Event 4: Timestamp 4
While it might appear that Event 3 happened before Event 2, Lamport's clocks cannot
determine this. They only guarantee that:
•Event 1 happened before Event 2.
•Event 3 happened before Event 4.
Logical Time and Logical Clocks
• Logical time is a concept used to order events in a distributed system, even without precise physical clocks. Logical clocks are mechanisms to assign timestamps to
events in a way that reflects their causal order.
Types of Logical Clocks:
• Lamport Clocks:
• Assigns unique timestamps to events.
• Ensures a partial ordering of events.
• When a process sends a message, it includes its current timestamp.
• The receiver's clock is advanced to the maximum of its current value and the received timestamp.
• Vector Clocks:
• Assigns a vector of timestamps to each event.
• Provides a more precise ordering of events, especially when dealing with concurrent events.
• Each process maintains a vector of logical clocks, one for each process in the system.
• When an event occurs, the process increments its own clock in the vector.
• When a message is sent, the entire vector is included in the message.
Global States
• A global state of a distributed system is a snapshot of the state of all its processes and channels at a specific point in time. Capturing a consistent global state is
challenging due to the lack of a global clock and asynchronous communication.
Techniques for Capturing Global States:
• Snapshot Algorithms:
• Chandy-Lamport Algorithm: A distributed algorithm that records the state of each process and its outgoing messages.
• Distributed Snapshot Algorithm: A more efficient algorithm that allows processes to record their states independently.
• Logical Clocks:
• Lamport clocks and vector clocks can be used to order events and infer potential global states.
• By understanding and applying these concepts, distributed systems can achieve accurate timekeeping, efficient coordination, and consistent global states, leading
to improved performance and reliability.
Events
An event is a significant occurrence in a process's execution. It can be a message send, a message receive, or a change in the
process's state.
Process States
A process state represents the current state of a process at a particular point in time. It can be one of the following:
•Running: The process is currently executing instructions.
•Ready: The process is waiting to be executed.
•Blocked: The process is waiting for an event, such as I/O completion or a message arrival.
Ordering Events
To understand the causal relationships between events in a distributed system, we need to order them. Two common ordering
relations are:
•Happens-Before Relation (→):
•If a and b are events in the same process, and a occurs before b, then a → b.
•If a is the sending of a message, and b is the receiving of that message, then a → b.
•Concurrent Events: Two events a and b are concurrent if neither a → b nor b → a.
Logical Clocks
To assign timestamps to events in a distributed system, logical clocks are used. Two common types of logical clocks are:
•Lamport Clocks: Each process maintains a logical clock, which is incremented before each event. When a message is sent, the
sender's clock value is included in the message. The receiver's clock is then set to the maximum of its current value and the
received timestamp.
•Vector Clocks: Each process maintains a vector of logical clocks, one for each process in the system. When an event occurs, the
process increments its own clock in the vector. When a message is sent, the entire vector is included in the message. The receiver
updates its vector by taking the maximum of each corresponding element.
By understanding these concepts, we can analyze the behavior of distributed systems, debug problems, and design efficient
algorithms for various distributed applications.
Global States in Distributed Systems
A global state of a distributed system is a snapshot of the state of all its processes and channels at a specific
point in time. However, due to the lack of a global clock, capturing a consistent global state is challenging.
Challenges of Global States:
•Inconsistent Views: Different nodes may have different views of the system's state at a given time.
•Causality Violations: Events may appear to occur in a different order on different nodes.
Capturing Global States:
Several techniques are used to capture global states:
1.Snapshot Algorithms:
•Chandy-Lamport Algorithm: A distributed algorithm that records the state of each process and its outgoing
messages.
•Distributed Snapshot Algorithm: A more efficient algorithm that allows processes to record their states
independently.
2.Logical Clocks:
•Lamport clocks and vector clocks can be used to order events and infer potential global states.
Clock Synchronization in Distributed Systems

Clock synchronization is the process of ensuring that all clocks in a distributed system are aligned to a
common time reference. This is crucial for various reasons, including:
•Coordinating Actions: Enables accurate coordination of events and actions across different nodes.
•Timestamping Events: Provides consistent timestamps for events, facilitating debugging and analysis.
•Distributed File Systems: Helps maintain consistency in distributed file systems.
•Real-time Systems: Ensures timely execution of tasks in real-time systems.
•Security Protocols: Plays a role in authentication and secure communication protocols.
Challenges of Clock Synchronization
•Clock Drift: Individual clocks tend to drift apart over time due to hardware variations and environmental
factors.
•Network Delays: Network latency can introduce inaccuracies in time measurements.
•Message Transmission Time: The time taken for messages to travel between nodes can vary.
Clock Synchronization: Centralized vs. Distributed Systems

Centralized Clock Synchronization

In a centralized system, a single authoritative time source (often called a time server) is responsible for maintaining accurate time. Other
nodes in the system synchronize their clocks with this time server.
Key characteristics:
•Simple: A straightforward approach where all nodes rely on a single source.
•Scalability: Can be less scalable as the number of nodes increases, as the time server becomes a single point of failure.
•Accuracy: Relies on the accuracy of the time server and the network latency between the server and the nodes.

Distributed Clock Synchronization

In a distributed system, there is no single authoritative time source. Instead, nodes synchronize their clocks with each other using various
algorithms.
Key characteristics:
•Complex: Requires more sophisticated algorithms to ensure consistency and accuracy.
•Scalability: More scalable as it distributes the synchronization responsibility across multiple nodes.
•Accuracy: Can be less accurate than centralized synchronization due to network delays and clock drift.
Common Algorithms for Distributed Clock Synchronization:
•Network Time Protocol (NTP):
•Hierarchical architecture with time servers at different levels.
•Uses a probabilistic algorithm to estimate network delays and adjust clocks accordingly.
•Precision Time Protocol (PTP):
•Designed for precise time synchronization, especially in industrial and telecommunications networks.
•Uses a deterministic algorithm to calculate network delays.
•Offers lower latency and higher accuracy than NTP.
Key Differences

Feature Centralized Distributed

Multiple nodes synchronize with
Time Source Single, authoritative time server
each other
Complexity Simpler More complex
Scalability Less scalable More scalable
Can be less accurate due to
Accuracy Relies on time server accuracy
network delays and clock drift
Why Clock Synchronization is Important:
•Coordinated Actions: It enables accurate coordination of events and actions across different nodes.
•Timestamping Events: It provides a consistent timestamp for events, facilitating debugging and analysis.
•Distributed File Systems: It helps maintain consistency in distributed file systems.
•Real-time Systems: It ensures timely execution of tasks in real-time systems.
•Security Protocols: It plays a role in authentication and secure communication protocols.

Challenges in Clock Synchronization:

•Clock Drift: Individual clocks tend to drift apart over time due to hardware variations and environmental factors.
•Network Delays: Network latency can introduce inaccuracies in time measurements.
•Message Transmission Time: The time taken for messages to travel between nodes can vary.

Coordinated Universal Time – abbreviated as UTC (from the French equivalent) – is an international standard for
timekeeping. It is based on atomic time, but a so-called ‘leap second’ is inserted – or, more rarely, deleted –
occasionally to keep it in step with astronomical time.
Clock Synchronization Algorithms
Several algorithms have been developed to address these challenges:
1.Network Time Protocol (NTP):
•Widely used for accurate time synchronization.
•Employs a hierarchical architecture with time servers at different levels.
•Uses a probabilistic algorithm to estimate network delays and adjust clocks accordingly.
2.Precision Time Protocol (PTP):
•Designed for precise time synchronization, especially in industrial and telecommunications networks.
•Uses a deterministic algorithm to calculate network delays.
•Offers lower latency and higher accuracy than NTP.
3.Cristian's Algorithm:
•A simple algorithm where a client requests the time from a time server.
•The client calculates the round-trip time and adjusts its clock accordingly.
•Less accurate than NTP and PTP, but can be used in simpler scenarios.
Key Considerations for Clock Synchronization:
•Accuracy: The desired level of accuracy depends on the specific application requirements.
•Reliability: The algorithm should be robust and fault-tolerant.
•Scalability: The algorithm should be able to handle large-scale distributed systems.
•Security: In security-sensitive applications, cryptographic techniques can be used to protect time synchronization.
By carefully selecting and implementing appropriate clock synchronization algorithms, distributed systems can achieve
the necessary level of time consistency, enabling reliable and efficient operation.
Global States in Distributed Systems
• A global state of a distributed system is a snapshot of the state of all its processes and channels at a specific point in time.
Capturing a consistent global state is challenging due to the lack of a global clock and asynchronous communication.
Why Global States Matter:
• Debugging: Understanding the system's state at a specific point in time can help identify and fix bugs.
• Performance Analysis: Analyzing global states can help identify performance bottlenecks.
• Fault Tolerance: Detecting and recovering from failures often requires knowledge of the system's global state.
Challenges in Capturing Global States:
• Inconsistent Views: Different nodes may have different views of the system's state at a given time.
• Causality Violations: Events may appear to occur in a different order on different nodes.

Techniques for Capturing Global States:

1. Snapshot Algorithms:
1. Chandy-Lamport Algorithm: A distributed algorithm that records the state of each process and its outgoing messages.
2. Distributed Snapshot Algorithm: A more efficient algorithm that allows processes to record their states independently.
2. Logical Clocks:
Lamport clocks and vector clocks can be used to order events and infer potential global states
Distributed Debugging
• Distributed debugging is the process of identifying and fixing bugs in distributed systems. It's a complex task due to the
asynchronous nature of distributed systems and the lack of a global clock.
Challenges in Distributed Debugging:
• Non-deterministic Behavior: The behavior of a distributed system can vary depending on the timing of events and network
conditions.
• Lack of a Global View: It's difficult to get a consistent view of the system's state.
• High Latency and Asynchronous Communication: Debugging tools may have high latency, making it difficult to analyze the
system's behavior in real-time.
Techniques for Distributed Debugging:
• Logging: Each node logs its activities, including timestamps, messages sent and received, and internal state changes.
• Tracing: Tracing tools can be used to track the flow of messages and execution of processes.
• Debugging Tools: Specialized debugging tools can help visualize the execution of distributed systems and identify problems.
• Global State Analysis: Capturing global states can help identify inconsistencies and anomalies.
• Replay Techniques: Replay techniques can be used to reproduce bugs by replaying the execution of the system.
By understanding the challenges and techniques associated with global states and distributed debugging, developers can build more
reliable and efficient distributed systems.
 Coordination and Agreement
Introduction

 Coordination and agreement in distributed systems involve

mechanisms and protocols that allow processes to work together
towards a common goal or make collective decisions.
 These concepts are crucial in scenarios where processes need to
coordinate their actions, share information, and ensure consistency
and reliability despite potential failures and communication delays.
 Coordination and Agreement
Distributed Mutual Exclusion

 Distributed processes require a mechanism that can

coordinate their activities because they share a
resource or collection of resources
 Mutual exclusion is required to
prevent interference
ensure consistency when accessing the resources

Process 2
Process 1 Process 3

…
Shared Process n
resource
 Coordination and Agreement
Distributed Mutual Exclusion

 Algorithms for mutual exclusion

Requirements for mutual exclusion are:
• Safety - At most one process may execute in the critical section (CS) at a time.
• Liveness - Requests to enter and exit the critical section eventually succeed.
• Ordering - If one request to enter the CS happened-before another, then entry to the CS
is granted in that order.
 Coordination and Agreement
Distributed Mutual Exclusion

 Algorithms for mutual exclusion

The criteria:
• the bandwidth consumed, which is proportional to the number of messages sent in each
entry and exit operation;
• the client delay incurred by a process at each entry and exit operation;
• the algorithm’s effect upon the throughput of the system.
Some examples of algorithms:
• The central server algorithm
• Ring-Based Algorithm
• Multicast and Logical Clocks
• Maekawa’s Voting Algorithm
 Coordination and Agreement
Distributed Mutual Exclusion

 The central server algorithm

In this approach, a central server acts as a coordinator, and processes
request access to the critical section by sending requests to the server.
The server grants access to one process at a time, ensuring mutual
exclusion.
 Coordination and Agreement
Distributed Mutual Exclusion

 The central server algorithm

Employs a server that grants permission to enter the critical section.
 Coordination and Agreement
Distributed Mutual Exclusion

 Ring-Based Algorithm
In the ring-based algorithm, processes are organized in a logical ring.
A token is passed among the processes, and only the process holding
the token can enter the critical section.
 Coordination and Agreement
Distributed Mutual Exclusion

 Ring-Based Algorithm
Arrange the processes in a logical ring
 Coordination and Agreement
Distributed Mutual Exclusion

 Multicast and Logical Clocks

This approach combines multicast communication and logical clocks
to achieve distributed mutual exclusion.
Processes send requests to enter the critical section via multicast, and
logical clocks are used to order the requests and determine the
process with the highest priority.
 Coordination and Agreement
Distributed Mutual Exclusion

 Multicast and Logical Clocks

processes that require entry to a critical section
multicast a request message, and can enter it only when
all the other processes have replied to this message
Election Algorithm
 In distributed algorithms, a coordinator is often required, and the Election
Algorithm serves this purpose by selecting a unique coordinator.
 This technique is crucial for designating a leader among a group of
processors.
 In the event that the current leader process becomes unavailable, the
algorithm is employed to identify a replacement leader from the remaining
processors.
 The algorithm’s decision on where to initiate a new leader is based on the
unique priority numbers assigned to each active process in the system.
 The process with the highest priority assumes the role of the new leader
when necessary. Consequently, when the leader experiences a failure, the
algorithm identifies the active process with the highest priority and shares
this information with all active processes in the system.
 It’s important to note that there are two distinct election algorithms — Bully
and Ring Algorithm — designed for different distributed system
 Coordination and Agreement
Election Algorithm

 Elections, or leader elections, occur when a group of processes

needs to select a single process as a leader or coordinator.
 An algorithm for choosing a unique process to play a particular
role
a process pi can be
• a participant : is engaged in some run of the election algorithm
• a non-participant : is not currently engaged in any election
Some examples of election algorithms
• A ring-based election algorithm
• The bully algorithm
 Coordination and Agreement
Election
Ring election

Ring Topology: Processes are arranged in a ring, and each process knows its neighbors.
•Election Initiation: A process initiates an election by sending an election message with its ID
to its neighbor.
•Message Passing: Each process that receives an election message compares its ID with the
received ID.
•If its ID is higher, it overwrites the message with its own ID and forwards it.
•If its ID is lower, it simply forwards the message.
•Coordinator Selection: The message eventually reaches the process with the highest ID,
which becomes the coordinator.
1 It then sends a coordinator message around the ring.
 Coordination and Agreement
Election
Example 2
Bully Algorithm
 Coordination and Agreement
Election
example1
Example 2
Election algorithm

 The following takes place when a process, say “P” sends a message to the coordinator:
1. If the coordinator remains unresponsive for the specified time interval “t,” it is considered a coordinator
failure.
2. Process “P” broadcasts an election message to all processes with a higher-priority numerical value.
3. It waits for a response. If there’s no response within time interval “t,” process “P” self-elects as coordinator.
4. It transmits a notification to lower-priority numbers and the process “P,” becomes the new coordinator.
 example3
 Election
 Coordination and Agreement
Multicast Communication

 Multicast communication involves the transmission of messages from

a single sender to multiple receivers simultaneously.

 It is a group communication mechanism where a sender sends a single

message, and it is delivered to all members of a group.
 Coordination and Agreement
Consensus and Related Problems

Consensus in Distributed Systems

 In a distributed system, consensus refers to the agreement among all nodes on a common value or state. This is a fundamental problem in
distributed computing, especially when dealing with fault-tolerant systems. Consensus algorithms are designed to ensure that all nodes
agree on a single value, even in the presence of failures or network partitions.
What is Consensus?
 Consensus in a distributed system refers to the process by which multiple nodes or components in a network agree on a single value or a
course of action despite potential failures or differences in their initial states or inputs. It's crucial for ensuring consistency and reliability in
decentralized environments where nodes may operate independently and may experience delays or failures.

Why Consensus is Important:

• Data Consistency: Ensuring that all nodes in a distributed system have a consistent view of the data.
• Fault Tolerance: Enabling the system to continue functioning correctly even if some nodes fail.
• Distributed Decision Making: Allowing a group of nodes to collectively make decisions.
Key Properties of a Consensus Algorithm:
1. Agreement: All correct processes must decide on the same value.
2. Termination: Every correct process must eventually decide.
3. Validity: The decided value must be proposed by at least one process.
Popular Consensus Algorithms:
1. Paxos:
1. Complex algorithm with multiple phases.
2. Offers high fault tolerance.
3. Difficult to implement and understand.
2. Raft:
1. Simpler to understand and implement than Paxos.
2. Uses leader election, log replication, and membership changes.
3. Less fault-tolerant than Paxos in some scenarios.
3. Byzantine Fault Tolerance (BFT):
1. Handles malicious nodes that can deviate from the protocol.
2. Requires a significant number of nodes to achieve consensus.
3. Used in highly secure systems like blockchain.
Challenges in Consensus:
• Network Partitions: When the network is divided into multiple segments, consensus becomes challenging.
• Node Failures: If nodes fail, the system must be able to reconfigure and elect a new leader.
• Timing Issues: Asynchronous systems can lead to timing-related issues and inconsistencies.
Applications of Consensus:
• Distributed Databases: Ensuring data consistency and availability across multiple nodes.
• Blockchain: Securing and validating transactions in a decentralized manner.
• Cloud Storage: Maintaining data integrity and consistency in distributed storage systems.
• Distributed File Systems: Coordinating access and updates to files across multiple servers.
 By understanding the principles of consensus algorithms and their challenges, you can design and implement reliable and fault-tolerant distributed systems.
 Coordination and Agreement
Consensus and Related Problems
Related Problems
 Several problems are closely linked to consensus in distributed systems:
1.Byzantine Fault Tolerance (BFT): This problem arises when some nodes in the
system may exhibit malicious or faulty behavior, intentionally or unintentionally
sending conflicting information. BFT algorithms aim to achieve consensus even in
the presence of such Byzantine failures.
2.Leader Election: In some distributed systems, a leader node is required to
coordinate and make decisions. Leader election algorithms ensure that a single
node is elected as the leader in a distributed manner.
3.Clock Synchronization: Inconsistent clocks can lead to problems in distributed
systems, such as incorrect ordering of events or difficulty in reaching consensus.
Clock synchronization algorithms aim to keep clocks across different nodes
synchronized.
4.Distributed Mutual Exclusion: This problem involves coordinating access to
shared resources among multiple nodes in a distributed system. Mutual exclusion
algorithms ensure that only one node can access a shared resource at a time.
 Coordination and Agreement
Consensus and Related Problems
The Byzantine Generals Problem
 The Byzantine Generals Problem is a classic computer science problem that illustrates the
challenges of achieving consensus in a distributed system where some nodes may be faulty or
malicious. It's named after a metaphor involving a group of generals who must decide on a
coordinated attack, but some of them may be traitors who will send conflicting or misleading
messages.
Problem Statement:
 Imagine a group of generals who must decide whether to attack or retreat. They can only
communicate via messengers. The problem is that some of the generals might be traitors who will
send conflicting or misleading messages to the other generals. The goal is to devise a strategy that
ensures all loyal generals make the same decision, even if some generals are traitors.
Key Challenges:
• Faulty or Malicious Nodes: Some nodes (generals) may behave unpredictably, sending incorrect or
inconsistent messages.
• Communication Failures: Messages may be lost or delayed, making it difficult to coordinate
decisions.
• Time Delays: Messages may take different amounts of time to reach different nodes, leading to
inconsistencies.
Byzantine Fault Tolerance (BFT)
 Byzantine Fault Tolerance (BFT) is a class of algorithms designed to ensure the reliability of a system in the presence of faulty or malicious nodes. It's inspired by the
classic "Byzantine Generals Problem," where a group of generals must coordinate their actions despite the presence of traitors among them.
Key Concepts:
• Fault Tolerance: The ability of a system to continue operating correctly even if some components fail.
• Byzantine Failure: A failure where a component behaves in an arbitrary and unpredictable manner, potentially disrupting the system's operation.
How BFT Works:
BFT algorithms typically involve the following steps:
1. Proposal: A node proposes a value or decision.
2. Voting: Other nodes vote on the proposed value.
3. Decision: A consensus is reached based on the votes, even if some nodes are faulty or malicious.
Common BFT Algorithms:
• Paxos: A complex algorithm known for its strong theoretical guarantees but can be difficult to implement.
• Raft: A more recent algorithm that aims to be simpler and more practical than Paxos.
• Practical Byzantine Fault Tolerance (PBFT): A BFT algorithm designed for practical applications, often used in blockchain systems.
Applications of BFT:
• Blockchain Systems: BFT algorithms are used to ensure the security and reliability of blockchain networks, such as Bitcoin and Ethereum.
• Distributed Databases: BFT can be used to maintain data consistency and availability in distributed databases.
• Cloud Computing: BFT can be used to ensure the reliability of cloud services.
How Bitcoin and Blockchain Address the Problem:
Bitcoin and other blockchain systems employ a consensus mechanism called Proof-of-Work (PoW) to
solve the Byzantine Generals Problem. Here's how it works:
1.Mining: Nodes in the network compete to solve complex cryptographic puzzles.
2.Consensus: When a node solves a puzzle, it creates a new block containing a set of transactions. This
block is then broadcast to the network.
3.Validation: Other nodes in the network verify the validity of the block and its transactions.
4.Chain Formation: If the block is valid, it is added to the blockchain, creating a chain of blocks.
Key Points:
•Decentralization: Blockchain networks are decentralized, meaning there is no central authority. This
eliminates the single point of failure and makes the system more resilient to attacks.
•Security: The PoW mechanism requires significant computational power to solve puzzles, making it
difficult for malicious actors to manipulate the network.
•Transparency: All transactions are recorded on the blockchain, making them transparent and
verifiable.
•Immutability: Once a block is added to the blockchain, it is extremely difficult to alter or remove,
ensuring data integrity.
In Summary:
Bitcoin and blockchain technology provide a practical solution to the Byzantine Generals Problem by
leveraging a decentralized network, cryptographic techniques, and a consensus mechanism like PoW.
This ensures that the network can operate reliably and securely, even in the presence of malicious actors.
 Assignment
 Common BFT Algorithms:Paxos, Raft, Practical Byzantine Fault
Tolerance (PBFT)
 how The Byzantine Generals Problem relate with bitcoin and
blockchain(discuss in detail blockchain and bitcoin)