Add files via upload

Author: Adityasinghvats

processcomm/README.md

@@ -0,0 +1,8 @@
+- This repo is meant to be a code repo for the algorithms used for process synchronisation
+- How to prevent deadlocks, mutexes and semaphores.
+- consumer-producer is a buffer for producers to give info and consumer to take info, producer needs to know when to sleep and stop producing and consumer needs to know how to and when to stop consuming
+- buffer is a shared resource so there should be context sync between both, to prevent a situation where consumer and procucer both sleep.
+- CS - critical section.
+- Semaphores , mutex are kind of locks, conditional variable , use TSL (Test and set lock instruction) under the hood to user kernel to manage processes.
+- COnditional variable doesn't check for wakeup call continuously, thus saving clock cycles.
+- When a semaphore is working it disables hardware interrupts, which means semaphores are atomic

processcomm/lockVariable.cpp

@@ -0,0 +1,34 @@
+#include<iostream>
+#include<thread>
+
+int lock = 0;
+
+class thread_object{
+public:
+     void operator()(int &x){
+        for(int i=0;i< 10000000;i++){
+            while(lock != 0);
+            lock = 1;//lock acquired
+            x += 1;
+            lock = 0; //lock left
+        }
+     }
+};
+/*
+for i < 10000 , x = 20000
+for i < 10^7 , x = 15758112
+*/
+
+int main(){
+    int x = 0;
+    thread_object obj;
+    std::thread t1(obj, std::ref(x)); //Process a
+    std::thread t2(obj, std::ref(x)); //Process b
+
+    t1.join();
+    t2.join();
+
+    std::cout<<"Final value of x:"<<x<<std::endl;
+
+    return 0;
+}

processcomm/main

@@ -0,0 +1,45 @@
+#include<iostream>
+#include<thread>
+using namespace std;
+
+//this algo solves the problems of concurrency of lockVariable approach and waitTurn approach
+
+#define TRUE 1
+#define FALSE 0
+#define N 2
+
+int turn = 0;
+int interested[N];
+int x = 0;
+
+void enter_section(int process){
+    int other = 1 - process;
+    interested[other] = TRUE;
+    turn = process;
+    while(turn == process && interested[other] == TRUE);
+}
+
+void leave_section(int process){
+    interested[process] = FALSE;
+}
+
+class thread_object{
+    public:
+    void operator()(int process){
+        for(int i=0;i<1000000000; i++){
+            enter_section(process);
+            x += 1;
+            cout<<"Thread "<<process<<" "<<x<<endl;
+            leave_section(process);
+        }
+    }
+};
+
+int main(){
+    thread_object obj;
+    std::thread t1(obj, 0);
+    std::thread t2(obj, 1);
+    t1.join();
+    t2.join();
+    return 0;
+}

processcomm/petersonSolution.cpp

@@ -0,0 +1,85 @@
+#include<iostream>
+#include<queue>
+#include<thread>
+#include<mutex>
+#include<condition_variable>
+
+class Semaphore{
+    private:
+    std::mutex mutex_m;
+    std::condition_variable condition_c;
+    unsigned long count_c = 0; //Initilaized as lock
+    public:
+    Semaphore(int value){
+        count_c = value;
+    }
+    void release(){ //one release is called it will run, without context switching, as it is atomic
+        std::lock_guard<std::mutex> lock(mutex_m);
+        ++count_c;
+        //type mutex wrapper, automatically locks mutex and when it is out of scope releases it
+        //ensure that mutex is released even if there is an error
+        condition_c.notify_one();
+    }
+    void acquire(){
+        std::unique_lock<std::mutex> lock(mutex_m);
+        while(!count_c) condition_c.wait(lock);// handle spurious wake-ups
+        --count_c;
+    }
+};
+
+std::mutex mtx;
+std::queue<int> buffer;
+const unsigned int MAX_BUFFER_SIZE = 10;
+
+Semaphore empty_slots(MAX_BUFFER_SIZE);//semaphore for empty slots
+Semaphore filled_slots(0);//semaphore for filled slots
+
+void producer(int value){
+    empty_slots.acquire();//what if there is no empty slots
+
+    {
+        /*
+        Inside this scope code will run using lock_guard
+        ans destructed once scope is finished
+        */
+        std::lock_guard<std::mutex> lock(mtx);
+        buffer.push(value); //as producer keeps on producing, fill the buffer for semaphore to know
+        std::cout<<"Producing "<<value<<std::endl;
+        std::cout<<"Buffer after producing: "<<buffer.size()<<std::endl<<std::endl;
+    }
+    filled_slots.release(); //signal thta a slot has been filled
+}
+void consumer(){
+    filled_slots.acquire();//what if there is no filled slots
+    int value;
+    {
+        /*
+        Inside this scope code will run using lock_guard
+        ans destructed once scope is finished
+        */
+        std::lock_guard<std::mutex> lock(mtx);
+        value = buffer.front();
+        buffer.pop(); //as producer keeps on producing, fill the buffer for semaphore to know
+        std::cout<<"Consuming "<<value<<std::endl;
+        std::cout<<"Buffer after Consuming: "<<buffer.size()<<std::endl<<std::endl;
+    }
+    empty_slots.release(); //signal that a slot has been emptied
+}
+
+int main(){
+    std::thread producerThread([]{ //spwan 20 threads
+        for(int i=1;i<=2000;++i){
+            producer(i);
+        }
+    });
+    // std::this_thread::sleep_for(std::chrono::milliseconds(10)); 
+    std::thread consumerThread([]{
+        for(int i=1;i<=2000;++i){
+            consumer();
+        }
+    });
+    producerThread.join();
+    consumerThread.join();
+    
+    return 0;
+}

processcomm/producerConsumer.cpp

@@ -0,0 +1,51 @@
+#include<iostream>
+#include<thread>
+
+int turn = 0;
+
+class thread1{
+    public:
+    void non_critical_section(){
+        int a = 0;
+        while(++a < 10);
+    }
+    void operator()(int &x){
+        while(true){
+            while(turn != 0); // loop and wait
+            x += 1;
+            std::cout<<"Thread 1"<<x<<std::endl;
+            turn = 1;
+            non_critical_section();
+        }
+    }
+};
+// this proves that if non_critical_section of a process is large 
+// it can delay and slow down other process in waitTurn
+class thread2{
+    public:
+    void non_critical_section(){
+        int a = 0;
+        while(++a < 1000000000);
+    }
+    void operator()(int &x){
+        while(true){
+            while(turn != 1); // loop and wait
+            x += 1;
+            std::cout<<"Thread 2"<<x<<std::endl;
+            turn = 0;
+            non_critical_section();
+        }
+    }
+};
+int main(){
+    int x = 0;
+    thread1 obj1;
+    thread2 obj2;
+    std::thread t1(obj1, std::ref(x)); //Process a
+    std::thread t2(obj2, std::ref(x)); //Process b
+
+    t1.join();
+    t2.join();
+
+    return 0;
+}