DISTRIBUTED SYSTEMS LAB FILE
(KCS751A)
Name: Chirag Mittal
Roll. No.: 2102300100057
College Roll No.: 16059
Year: 4th Year
Branch: CSE
INDEX
Sno. Name Of Program Page No. Remarks
WAP to simulate the
functionality of Lamport's
1 Logical clock in C.
WAP to Implement Vector
clock in C.
2
Simulation of Distributed
mutual exclusion in java.
3
Implementation of CORBA
(Common Object Request
4 Broker Architecture)
mechanism.
Implementation of Path
Pushing Algorithm
5
Implementation of Edge
Chasing Algorithm
6
Implementation of Commit
Protocol Algorithm
7
Implementation of Voting
Protocol Algorithm
8
EXPERIMENT 1
Objective: WAP to simulate the functionality of Lamport's
Logical clock in C.
#include <stdio.h>
#include <stdlib.h>
#define MAX_EVENTS 100
int max(int a, int b) {
return (a > b) ? a : b;
}
void lamport_logical_clock(int events[], int n) {
int logical_clock[MAX_EVENTS] = {0}; // Array to store logical clock
values
logical_clock[0] = 1;
for (int i = 1; i < n; i++) {
logical_clock[i] = max(logical_clock[i - 1], events[i]) + 1;
}
printf("\nEvent\tTimestamp\n");
for (int i = 0; i < n; i++) {
printf("E%d\t%d\n", i + 1, logical_clock[i]);
}
}
int main() {
int n;
printf("Enter the number of events: ");
scanf("%d", &n);
if (n <= 0 || n > MAX_EVENTS) {
printf("Invalid number of events. Please enter a value between 1
and %d.\n", MAX_EVENTS);
return -1;
}
int events[MAX_EVENTS];
printf("Enter the dependencies for each event (0 if independent):\n");
for (int i = 0; i < n; i++) {
printf("Event E%d: ", i + 1);
scanf("%d", &events[i]);
}
lamport_logical_clock(events, n);
return 0;
}
Output:
EXPERIMENT 2
Objective: WAP to Implement Vector clock in C.
#include <stdio.h>
#define MAX 10
void initialize(int vc[MAX][MAX], int n) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
vc[i][j] = 0;
}
void display(int vc[MAX][MAX], int n) {
printf("\nVector Clock:\n");
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
printf("%d ", vc[i][j]);
}
printf("\n");
}
}
void internal_event(int vc[MAX][MAX], int pid) {
vc[pid][pid]++;
}
void message_event(int vc[MAX][MAX], int sender, int receiver, int n) {
vc[sender][sender]++;
for (int i = 0; i < n; i++)
vc[receiver][i] = (vc[receiver][i] > vc[sender][i]) ?
vc[receiver][i] : vc[sender][i];
vc[receiver][receiver]++;
}
int main() {
int n, vc[MAX][MAX], choice, p1, p2;
printf("Enter number of processes (max %d): ", MAX);
scanf("%d", &n);
initialize(vc, n);
while (1) {
printf("\n1. Internal Event\n2. Message Event\n3. Display Clock\n4.
Exit\nChoice: ");
scanf("%d", &choice);
switch (choice) {
case 1:
printf("Enter process ID: ");
scanf("%d", &p1);
internal_event(vc, p1 - 1);
break;
case 2:
printf("Enter sender and receiver IDs: ");
scanf("%d %d", &p1, &p2);
message_event(vc, p1 - 1, p2 - 1, n);
break;
case 3:
display(vc, n);
break;
case 4:
return 0;
default:
printf("Invalid choice!\n");
}
}
return 0;
}
Output:
EXPERIMENT 3
Objective: Simulation of Distributed mutual exclusion in
java.
import java.util.Scanner;
public class DistributedMutex {
private static final int MAX_PROCESSES = 10;
private static boolean[] requestQueue = new boolean[MAX_PROCESSES];
private static boolean[] replyQueue = new boolean[MAX_PROCESSES];
private static boolean criticalSection = false;
private static int processId;
private static int totalProcesses;
// Request access to the critical section
public static void requestCriticalSection(int process) {
System.out.println("Process " + process + " is requesting critical
section...");
for (int i = 0; i < totalProcesses; i++) {
if (i != process) {
System.out.println("Process " + process + " sends REQUEST
to Process " + i);
requestQueue[i] = true;
}
}
grantCriticalSection(process);
}
// Grant access to the critical section
public static void grantCriticalSection(int process) {
boolean canEnter = true;
for (int i = 0; i < totalProcesses; i++) {
if (i != process && requestQueue[i]) {
canEnter = false;
break;
}
}
if (canEnter) {
enterCriticalSection(process);
} else {
System.out.println("Process " + process + " is waiting for
replies...");
}
}
// Enter the critical section
public static void enterCriticalSection(int process) {
criticalSection = true;
System.out.println("Process " + process + " enters the critical
section.");
try {
Thread.sleep(2000); // Simulate some work in the critical
section
} catch (InterruptedException e) {
e.printStackTrace();
}
leaveCriticalSection(process);
}
// Leave the critical section
public static void leaveCriticalSection(int process) {
System.out.println("Process " + process + " leaves the critical
section.");
criticalSection = false;
for (int i = 0; i < totalProcesses; i++) {
if (i != process && requestQueue[i]) {
System.out.println("Process " + process + " sends REPLY to
Process " + i);
replyQueue[i] = true;
}
}
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// Input number of processes
System.out.print("Enter the number of processes (max " +
MAX_PROCESSES + "): ");
totalProcesses = scanner.nextInt();
if (totalProcesses <= 0 || totalProcesses > MAX_PROCESSES) {
System.out.println("Invalid number of processes.");
return;
}
// Initialize request and reply queues
for (int i = 0; i < MAX_PROCESSES; i++) {
requestQueue[i] = false;
replyQueue[i] = false;
}
while (true) {
System.out.print("\n1. Request Critical Section\n2. Exit\nEnter
your choice: ");
int choice = scanner.nextInt();
switch (choice) {
case 1:
System.out.print("Enter process ID (0 to " +
(totalProcesses - 1) + "): ");
processId = scanner.nextInt();
if (processId < 0 || processId >= totalProcesses) {
System.out.println("Invalid process ID.");
} else if (criticalSection) {
System.out.println("Critical section is currently
occupied. Try again later.");
} else {
requestCriticalSection(processId);
}
break;
case 2:
System.out.println("Exiting...");
scanner.close();
return;
default:
System.out.println("Invalid choice. Please try
again.");
}
}
}
}
EXPERIMENT 4
Objective: Implementation of CORBA (Common Object
Request Broker Architecture) mechanism.
Step 1: Hello.idl
module HelloApp {
interface Hello {
string sayHello();
};
};
Step 2: HelloServer.java
import HelloApp.*;
import org.omg.CORBA.*;
import org.omg.PortableServer.*;
public class HelloServer {
public static void main(String[] args) {
try {
// Initialize ORB
ORB orb = ORB.init(args, null);
// Get reference to RootPOA and activate POAManager
POA rootPOA =
POAHelper.narrow(orb.resolve_initial_references("RootPOA"));
rootPOA.the_POAManager().activate();
// Create servant and register with ORB
HelloServant helloRef = new HelloServant();
org.omg.CORBA.Object ref =
rootPOA.servant_to_reference(helloRef);
Hello helloRefHello = HelloHelper.narrow(ref);
// Bind the object reference in the Naming Service
org.omg.CORBA.Object objRef =
orb.resolve_initial_references("NameService");
NamingContextExt ncRef =
NamingContextExtHelper.narrow(objRef);
NameComponent[] path = ncRef.to_name("Hello");
ncRef.rebind(path, helloRefHello);
System.out.println("HelloServer ready and waiting...");
// Keep server running
orb.run();
} catch (Exception e) {
e.printStackTrace();
}
}
}
class HelloServant extends HelloPOA {
public String sayHello() {
return "Hello from CORBA Server!";
}
}
Step 3: HelloClient.java
import HelloApp.*;
import org.omg.CORBA.*;
import org.omg.CosNaming.*;
public class HelloClient {
public static void main(String[] args) {
try {
// Initialize ORB
ORB orb = ORB.init(args, null);
// Get reference to Naming Service
org.omg.CORBA.Object objRef =
orb.resolve_initial_references("NameService");
NamingContextExt ncRef =
NamingContextExtHelper.narrow(objRef);
// Resolve the object reference
Hello helloRef =
HelloHelper.narrow(ncRef.resolve_str("Hello"));
// Call the method on the server
String response = helloRef.sayHello();
System.out.println("Response from server: " + response);
} catch (Exception e) {
e.printStackTrace();
}
}
}
EXPERIMENT 5
Objective: Implementation of Path Pushing Algorithm
class Graph:
def __init__(self, vertices):
self.vertices = vertices
self.edges = []
def add_edge(self, source, destination, weight):
self.edges.append((source, destination, weight))
def path_pushing_algorithm(self, start_vertex):
# Initialize distance table
paths = {v: {} for v in range(self.vertices)}
paths[start_vertex][start_vertex] = 0
# Repeat path pushing until no updates
updated = True
while updated:
updated = False
for source, destination, weight in self.edges:
for path, current_cost in paths[source].items():
new_cost = current_cost + weight
if path not in paths[destination] or
paths[destination][path] > new_cost:
paths[destination][path] = new_cost
updated = True
# Print the shortest paths
for vertex in range(self.vertices):
print(f"Shortest paths from vertex {start_vertex} to
{vertex}:")
for path, cost in paths[vertex].items():
print(f" Path via {path}, Cost: {cost}")
if __name__ == "__main__":
vertices = int(input("Enter the number of vertices: "))
edges = int(input("Enter the number of edges: "))
graph = Graph(vertices)
print("Enter the edges (source, destination, weight):")
for _ in range(edges):
source, destination, weight = map(int, input().split())
graph.add_edge(source, destination, weight)
start_vertex = int(input("Enter the starting vertex: "))
graph.path_pushing_algorithm(start_vertex)
Output:
EXPERIMENT 6
Objective: Implementation of Edge Chasing Algorithm
class Process:
def __init__(self, pid):
self.pid = pid
self.waiting_for = [] # Processes this process is waiting for
def add_dependency(self, process):
self.waiting_for.append(process)
def detect_deadlock(self, visited):
if self.pid in visited:
return True # Deadlock detected
visited.add(self.pid)
for process in self.waiting_for:
if process.detect_deadlock(visited):
return True
visited.remove(self.pid) # Backtrack
return False
if __name__ == "__main__":
# Create processes
num_processes = int(input("Enter the number of processes: "))
processes = {i: Process(i) for i in range(num_processes)}
# Add dependencies
print("Enter dependencies (process waiting for another process). Enter
-1 -1 to stop:")
while True:
p1, p2 = map(int, input().split())
if p1 == -1 and p2 == -1:
break
processes[p1].add_dependency(processes[p2])
# Initiate deadlock detection
start_process = int(input("Enter the process initiating the probe: "))
if processes[start_process].detect_deadlock(set()):
print("Deadlock detected!")
else:
print("No deadlock detected.")
Output:
EXPERIMENT 7
Objective: Implementation of Commit Protocol Algorithm
class Participant:
def __init__(self, pid):
self.pid = pid
self.vote = None # 'commit' or 'abort'
def decide_vote(self):
import random
self.vote = random.choice(['commit', 'abort'])
print(f"Participant {self.pid} votes {self.vote}")
return self.vote
class Coordinator:
def __init__(self, participants):
self.participants = participants
def two_phase_commit(self):
print("\nPhase 1: Voting Phase")
votes = []
for participant in self.participants:
votes.append(participant.decide_vote())
if 'abort' in votes:
print("\nPhase 2: Abort Phase")
print("Coordinator instructs all participants to ROLLBACK.")
self.rollback()
else:
print("\nPhase 2: Commit Phase")
print("Coordinator instructs all participants to COMMIT.")
self.commit()
def commit(self):
for participant in self.participants:
print(f"Participant {participant.pid} commits transaction.")
def rollback(self):
for participant in self.participants:
print(f"Participant {participant.pid} rolls back transaction.")
if __name__ == "__main__":
num_participants = int(input("Enter the number of participants: "))
participants = [Participant(pid) for pid in range(num_participants)]
coordinator = Coordinator(participants)
coordinator.two_phase_commit()
Output:
EXPERIMENT 8
Objective: Implementation of Voting Protocol Algorithm
class Participant:
def __init__(self, pid):
self.pid = pid
self.vote = None # 'yes' or 'no'
def cast_vote(self):
import random
self.vote = random.choice(['yes', 'no'])
print(f"Participant {self.pid} votes {self.vote}")
return self.vote
class Coordinator:
def __init__(self, participants):
self.participants = participants
def execute_voting_protocol(self):
print("\nVoting Phase:")
votes = []
for participant in self.participants:
votes.append(participant.cast_vote())
# Decision Phase
print("\nDecision Phase:")
if 'no' in votes:
print("Consensus not achieved. The proposal is REJECTED.")
else:
print("Consensus achieved. The proposal is ACCEPTED.")
if __name__ == "__main__":
num_participants = int(input("Enter the number of participants: "))
participants = [Participant(pid) for pid in range(num_participants)]
coordinator = Coordinator(participants)
coordinator.execute_voting_protocol()
Output:
