1.

Message Ordering Paradigms:

o FIFO (First-In-First-Out) Order: Messages are delivered in the order they

are sent, for each sender.

o Causal Order: Messages are delivered following the causal relationships

between them.

o Total Order: All messages are delivered in the same order to all processes
in the system.

o Unordered: No specific order is imposed on message delivery.

2. Causal Order Execution:

o Causal order execution ensures that if one message causally precedes

another, it will be delivered in that order. This ordering respects the
"happens-before" relation to maintain consistency across distributed
systems.

3. Crown and Crown Criterion:

o Crown: A crown in distributed systems is a configuration of events and

communication that reveals a cycle of causal dependencies among a set
of nodes.

o Crown Criterion: It specifies the conditions under which events in a

system can be causally related, ensuring that certain dependencies and
ordering constraints are maintained in distributed execution.

4. Group Communication in Distributed Systems:

o Group communication allows multiple processes to participate in a

collective message exchange, enabling communication among a group of
nodes simultaneously. It’s often used for coordination, consistency, and
fault tolerance in distributed systems.

5. Issues in Recording a Global State:

o Coordination: Difficult to achieve without a synchronized clock.

o Consistency: Capturing a consistent state across all processes.

o Overhead: Increased communication and storage requirements.

o Fault Tolerance: Handling failures during state recording.

o Latency: Delay in achieving a synchronized view across processes.

6. Mutual Exclusion:

o Mutual exclusion in distributed systems is a principle ensuring that

multiple processes do not enter their critical sections at the same time.
This prevents conflicts and ensures data integrity.

7. Ways of Implementing Mutual Exclusion:

o Centralized Algorithm: Uses a central coordinator for granting access to

the critical section.

o Token Ring Algorithm: Uses a token passing approach where only the
process holding the token can access the critical section.

o Distributed Algorithm: Every process participates equally in granting

permission, often using voting or quorum-based methods.

8. Requirements of Mutual Exclusion Algorithms:

o Safety: At most one process should be in its critical section at a time.

o Liveness: Every request to enter a critical section must eventually be

granted.

o Ordering: Requests should be granted in the order they were made

(fairness).

o Fault Tolerance: Should be resilient to failures, depending on the

algorithm used.

9. Deadlock and Deadlock Models:

o Deadlock: A situation in distributed systems where a set of processes are

blocked because each process holds a resource and waits for another
held by another process.

o Models of Deadlocks:

▪ Resource Allocation Graph Model: Depicts resources and

processes, showing hold-and-wait relationships.

▪ Wait-for Graph Model: Focuses on processes waiting for

resources held by others.

▪ AND/OR Model: Categorizes resources into those that can be

requested in a cumulative (AND) or individual (OR) manner.

10. Components of Deadlock Detection Model:

o Process States: Status of each process (e.g., waiting, running).

 o Resource Allocation State: Which resources are held by which
processes.

o Wait-for Graph: Tracks dependencies among processes for resource

acquisition.

o Detection Algorithm: Mechanism to identify cycles or deadlock

configurations.

o Resolution Policy: Defines actions to resolve detected deadlocks, like

resource preemption or process termination.

IT PAPER:

1. Cut of a Distributed System:

o A cut in a distributed system is a snapshot representing the states of

multiple processes at a specific point in time. A cut can be consistent
(when the snapshot respects the causal order of events) or inconsistent
(when some dependencies are missed).

2. Message Ordering Paradigms:

o FIFO Order: Messages are delivered in the order they are sent, per sender.

o Causal Order: Messages are delivered respecting causal dependencies.

o Total Order: All processes receive messages in the same order.

o Unordered: No specific order is maintained in message delivery.

3. Crown and Crown Criterion:

o Crown: In distributed computing, a crown is a structure in the event graph

with a set of processes and events, arranged so that each event depends
on the previous one, forming a loop or circular dependency.

o Crown Criterion: This criterion defines conditions where causal

dependencies between events form a closed loop.

o Example: If Process A sends a message to Process B, B sends to C, and C

sends back to A, creating a dependency loop, it represents a crown.

4. Issues in Recording a Global State:

o Consistency: Ensuring the global state represents a snapshot with

causal order.

o Overhead: High communication and storage requirements.

o Coordination: Difficulty in synchronizing clocks across processes.

 o Fault Tolerance: Handling failures during state capture.

o Latency: Delays in communication affect accuracy of the state.

5. Criteria for Causal Ordering Protocol:

o Causal Consistency: Messages must respect causal relationships.

o Non-blocking: Protocol should not unduly delay message delivery.

o Efficient Overhead: Minimized overhead for tracking causality.

o Fault Tolerance: Should work despite failures in the network.

6. Requirements of Mutual Exclusion Algorithms:

o Safety: Only one process can be in the critical section at a time.

o Liveness: Requests should not be indefinitely delayed.

o Fairness: Requests are granted in order of their arrival.

o Fault Tolerance: Should handle process failures gracefully.

7. Idle Token in Token-Based Distributed Mutual Exclusion:

o An idle token is a token that is not held by any process currently needing
access to the critical section. It circulates or waits for a request to grant
access to the next requesting process.

8. Performance Comparison of Ricart-Agrawala Algorithm vs. Lamport’s

Algorithm:

o Ricart-Agrawala: Requires 2(N-1) messages per request where N is the

number of processes, and reduces communication as no central
coordinator is needed. However, it may have higher response time for
large N.

o Lamport’s Algorithm: Requires 3(N-1) messages per critical section entry

due to timestamped request and release messages, ensuring requests
are handled in order. It is more robust but has higher communication
overhead than Ricart-Agrawala.

9. Deadlock and Deadlock Handling Strategies:

o Deadlock: A condition in which a group of processes become blocked,

each waiting for resources held by the others.

o Deadlock Handling Strategies:

 ▪ Deadlock Prevention: Imposes resource allocation policies to
prevent cycles.

▪ Deadlock Avoidance: Ensures that the system never enters a

deadlocked state by careful resource allocation.

▪ Deadlock Detection and Recovery: Allows deadlock but

periodically checks for it and resolves by terminating or
preempting processes.

10. Wait-For Graph (WFG) and Deadlock Detection:

o WFG: A directed graph representing processes as nodes and wait

dependencies as directed edges.

o Deadlock Detection Using WFG: By analyzing cycles in the WFG, a

system can detect deadlocks; if a cycle exists, it indicates that a set of
processes is deadlocked.