Scribd Logo
Upload

Welcome to Scribd!

  • 21 views

    Distributed Computing File NSUT

    Uploaded by

    Vishu Aasliya
    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.

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd

    Distributed Computing File NSUT

    Uploaded by

    Vishu Aasliya
    21 views4 pages
    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.

    Original Description:

    Lab File for Distributed Computing NSUT Sem 5

    Copyright

    © © All Rights Reserved

    Available Formats

    PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    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.

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd
    Download as pdf or txt
    21 views4 pages

    Distributed Computing File NSUT

    Uploaded by

    Vishu Aasliya
    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.

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd
    Download as pdf or txt
    of 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