UPLOADED BANKERS AND BINARY SEMAPHORES

Author: Samyak-ja-in

10_Binary_Semaphore.cxx

@@ -0,0 +1,102 @@
+#include<iostream>
+#include<queue>
+using namespace std;
+
+int ct=0;
+struct process
+{
+    int id;
+    int bt;
+}p1,p2,p3;
+
+struct semaphore
+{
+    int value;
+    queue <process>q1;
+} s1;
+
+void signal();
+void critical_section(process a);
+
+void wait(process a[],int n)
+{
+    for(int i=1;i<n;i++)
+    (s1.q1).push(a[i]);
+
+    if(s1.value==1)
+    {
+        s1.value=0;
+        critical_section(a[0]);
+        
+    }
+
+}
+
+void showqueue(queue<process>q)
+{
+    process p;
+    while(!q.empty())
+    {
+        p=q.front();
+        q.pop();
+        cout<<" "<<p.id<<" ";
+    }
+    cout<<"\t"<<s1.value;
+}
+
+void critical_section(process a)
+{
+    cout<<"\n  "<<a.id<<"\t"<<a.bt<<"\t";
+    showqueue(s1.q1);
+    ct=ct+a.bt;
+    signal();
+}
+
+void signal()
+{
+    process p;
+    if(!s1.q1.empty())
+    {
+        p=s1.q1.front();
+        s1.q1.pop();
+        critical_section(p);
+    }
+    else
+    s1.value=1;
+}
+
+int main()
+{
+    int bt[20];int n;
+  
+
+    process a[3];
+    
+    s1.value=1;
+    
+    p1.id=1;
+    p1.bt=2;
+    
+
+    p2.id=2;
+    p2.bt=3;
+    
+
+    p3.id=3;
+    p3.bt=4;
+    
+
+    a[0]=p1;
+    a[1]=p2;
+    a[2]=p3;
+
+    cout<<"\n INITIALLY SEMPAHORE VALUE IS "<<s1.value;
+
+    cout<<"\nPRO ID\tBUR TI\tWAIT\tSEMAPHORE\n";
+    wait(a,3);
+    
+    cout<<"\nFINALLY SEMAPHORE VALUE "<<s1.value;
+    cout<<"\nCURRENT TIME NOW BECOMES "<<ct;
+
+
+}

9BANKERS_ALGORITHM.cxx

@@ -0,0 +1,153 @@
+#include<iostream>
+#include<queue>
+using namespace std;
+
+
+int main()
+{
+    int p,r,i,j;
+    int allocated[20][20];
+    int max[20][20];
+    int needed[20][20];
+    int available[20];
+    int total_allocated[20];
+    int total_available[20];
+    int flag[20];
+
+    cout<<"\nEnter number of process and number of resources ";
+    cin>>p;
+    cin>>r;
+
+    //TELLING COMPILER THAT THIS PROCESS IS NOT EXECUTED YET
+    for(i=0;i<p;i++)
+    flag[i]=0;
+
+    cout<<"\nEnter total available resources of each type ";
+    for(i=0;i<r;i++)
+    cin>>total_available[i];
+
+    cout<<"\nEnter data of resources each process allocated with ";
+    for(i=0;i<p;i++)
+    {
+        for(j=0;j<r;j++)
+        {
+            cin>>allocated[i][j];
+        }
+    }
+
+    cout<<"\nEnter data of resources each process needs maximum ";
+    for(i=0;i<p;i++)
+    {
+        for(j=0;j<r;j++)
+        {
+            cin>>max[i][j];
+        }
+    }
+    
+    //CALCULATING NEED MATRIX
+    for(i=0;i<p;i++)
+    {
+        for(j=0;j<r;j++)
+        {
+            needed[i][j]=max[i][j]-allocated[i][j];
+        }
+    }
+
+    cout<<"\n THE NEED MATRIX IS\n";
+    for(i=0;i<p;i++)
+    {
+        for(j=0;j<r;j++)
+        {
+            cout<<needed[i][j]<<"\t";
+        }
+        cout<<"\n";
+    }
+
+    int sum;
+    int k=0;
+    while(k<r)
+    {
+        sum=0;
+        for(i=0;i<p;i++)
+        {
+            sum=sum+allocated[i][k];
+        }
+        total_allocated[k]=sum;
+        k++;
+    }
+
+    cout<<"\nTotal number of resources allocated is ";
+    for(i=0;i<r;i++)
+    cout<<total_allocated[i]<<'\t';
+
+    cout<<"\nTotal resources available is ";
+    for(i=0;i<r;i++)
+    {
+        available[i]=total_available[i]-total_allocated[i];
+        cout<<available[i]<<"\t";
+    }
+
+    queue<int>sequence;
+
+    int count =0;
+    while(count!=p)
+    {
+        for(i=0;i<p;i++)
+        {
+            
+            int k=0;
+            if(flag[i]==0)
+            {   
+                int nota=1;
+                while(k<r)
+                {
+                    if(needed[i][k]>available[k])
+                    {
+                        nota=0;
+                        break;
+                    }
+                    k++;
+                }
+                if(nota==1)
+                {
+                    k=0;
+                    while(k<r)
+                    {
+                    available[k]=available[k]+allocated[i][k];
+                    k++;
+                    }
+                    flag[i]=1;
+                    sequence.push(i);
+                    break;                  //NOT REQUIRED JUST WRITTEN FOR START EXECUTION FROM UPWARDS ALWAYS
+                }
+
+            }
+        }
+        count++;
+    }
+
+    int safe=1;
+    for(i=0;i<p;i++)
+    {
+        if(flag[i]==0)
+        safe=0;
+
+    }
+    if(safe==1)
+    {
+        cout<<"\nONE OF THE SAFE SEQUENCE IS ";
+        while(!sequence.empty())
+        {
+            cout<<sequence.front()<<" ";
+            sequence.pop();
+        }
+    
+        cout<<"\nAT LAST AVAILABLE MATRIX IS ";
+        for(i=0;i<r;i++)
+        cout<<available[i]<<"\t";
+    }
+    else
+    {
+        cout<<"\nSAFE SEQUENCE COULD NOT BE FOUND";
+    }
+}