Scribd
Upload
50 views

Distributed Computing File NSUT

This document contains code snippets for 8 programs related to distributed systems concepts. The programs implement non-token based mutual exclusion, Lamport's logical clock, edge chasing distributed deadlock detection, locking for mutual exclusion, remote method invocation, remote procedure call, a chat server, and termination detection. Each code snippet is numbered and includes a brief description of the program it implements.

Uploaded by

Vishu Aasliya
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
50 views

Distributed Computing File NSUT

This document contains code snippets for 8 programs related to distributed systems concepts. The programs implement non-token based mutual exclusion, Lamport's logical clock, edge chasing distributed deadlock detection, locking for mutual exclusion, remote method invocation, remote procedure call, a chat server, and termination detection. Each code snippet is numbered and includes a brief description of the program it implements.

Uploaded by

Vishu Aasliya
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 4

‭2‬

‭Table Of Content‬
‭S. No.‬ ‭Experiment‬ ‭Pg No.‬ ‭Sign‬
‭1‬ ‭ rogram to implement non token‬
P ‭3‬
‭based algorithm for Mutual‬
‭Exclusion‬

‭2‬ ‭ rogram to implement Lamport’s‬


P ‭5‬
‭Logical Clock‬

‭3‬ ‭ rogram to implement edge chasing‬ ‭7‬


P
‭distributed deadlock detection‬
‭algorithm.‬

‭4‬ ‭ rogram to implement locking‬


P ‭8‬
‭algorithm for mutual exclusion‬

‭5‬ ‭ rogram to implement Remote‬


P ‭9‬
‭Method Invocation.‬

‭6‬ ‭ rogram to implement Remote‬


P ‭11‬
‭Procedure Call.‬

‭7‬ ‭Program to implement Chat Server.‬ ‭12‬

‭8‬ ‭ rogram to implement termination‬


P ‭14‬
‭Detection‬
‭7‬

‭ ab 3. Program to implement edge chasing distributed‬


L
‭deadlock detection algorithm‬
‭Code:‬
‭ include <bits/stdc++.h>‬
#
‭using namespace std;‬
‭bool deadlock(vector<vector<int>> sites, vector<vector<int>> edges){‬
‭int n = edges.size();‬
‭sort(edges.begin(), edges.end());‬
‭int a = sites[edges[0][0]][sites[edges[0][0]].size()-1];‬
‭int b = sites[edges[0][1]][0];‬
‭vector<int> probe = {1, a,b};‬
‭for(int i = 1; i<n; i++){‬
‭int a = sites[edges[i][0]][sites[edges[i][0]].size()-1];‬
‭int b = sites[edges[i][1]][0];‬
‭probe[1] = a;‬
‭probe[2] = b;‬
‭if(probe[0]==probe[2]){‬
‭return true;‬
‭}‬
‭}‬
‭return false;‬
‭}‬
‭int main(){‬
‭vector<vector<int>> sites = {{1,2,3}, {4,5}, {6,7,8}, {9,10,11,12}};‬
‭vector<vector<int>> edges = {{0,1}, {1,2}, {2,3},{3,0}};‬
‭if(deadlock(sites, edges)){‬
‭cout<<"Deadlock Detected";‬
‭}‬
‭else{‬
‭cout<<"No Deadlock Detected";‬
‭}‬
‭return 0;‬
‭}‬

‭Output:‬
‭8‬

‭ ab 4. Program to implement locking algorithm for mutual‬


L
‭exclusion‬
‭Code:‬
‭ include <iostream>‬
#
‭#include <thread>‬
‭#include <mutex>‬
‭using namespace std;‬
‭//locking algorithm using mutal exlusion‬
‭mutex mtx; // Declare a mutex‬
‭void critical_section(int thread_id) {‬
‭// Simulate the critical section‬
‭mtx.lock(); // Lock the mutex to enter the critical section‬
‭cout << "Thread " << thread_id << " is in the critical section." << endl;‬
‭mtx.unlock(); // Unlock the mutex to exit the critical section‬
‭}‬
‭//this_thread::sleep_for(chrono::milliseconds(3000));‬
‭int main() {‬
‭const int num_threads = 4;‬
‭thread threads[num_threads];‬
‭for (int i = 0; i < num_threads; ++i) {‬
‭threads[i] = thread(critical_section, i);‬
‭}‬

‭for (int i = 0; i < num_threads; ++i) {‬


‭threads[i].join();‬
‭}‬
‭return 0;‬
‭}‬

‭Output:‬
‭14‬

‭ ab 8. Program to implement termination detection‬


L
‭Code:‬
‭ include <iostream>‬
#
‭#include <vector>‬
‭#include <thread>‬
‭#include <atomic>‬
‭#include <chrono>‬
‭using namespace std;‬
‭const int NUM_PROCESSES = 5;‬
‭atomic<int> completedProcesses(0);‬
‭// Simulate a process‬
‭void process(int id) {‬
‭// Simulate some work‬
‭this_thread::sleep_for(chrono::milliseconds(2000));‬
‭// Signal that this process has completed‬
‭completedProcesses.fetch_add(1, memory_order_relaxed);}‬
‭int main() {‬
‭vector<thread> processes;‬
‭// Create and start the processes‬
‭for (int i = 0; i < NUM_PROCESSES; ++i) {‬
‭processes.push_back(thread(process, i));‬
‭cout<<"Process "<<i+1<<" created"<<endl;}‬
‭// Wait for all processes to complete‬
‭for (thread& t : processes) {‬
‭t.join();‬
‭while (completedProcesses.load(memory_order_relaxed) <‬
‭NUM_PROCESSES) {‬
‭cout << "Waiting for processes to complete..." << endl;‬
‭this_thread::sleep_for(chrono::milliseconds(500));}}‬
‭// Termination detection‬
‭cout<<completedProcesses.load(memory_order_relaxed)<<endl;‬
‭cout << "All processes have completed." << endl;‬
‭return 0;}‬
‭Output:‬

You might also like