Operating System

EXP NO: 1 Program for FCFS CPU Scheduling Algorithms to find turnaround time and
Date: waiting time.

#include<iostream>

using namespace std;

// Function to find the waiting time for all

// processes

void findWaitingTime(int processes[], int n,

int bt[], int wt[])

// waiting time for first process is 0

wt[0] = 0;

// calculating waiting time

for (int i = 1; i < n ; i++ )

wt[i] = bt[i-1] + wt[i-1] ;

// Function to calculate turn around time

void findTurnAroundTime( int processes[], int n,

int bt[], int wt[], int tat[])

1
 Operating System

// calculating turnaround time by adding

// bt[i] + wt[i]

for (int i = 0; i < n ; i++)

tat[i] = bt[i] + wt[i];

//Function to calculate average time

void findavgTime( int processes[], int n, int bt[])

int wt[n], tat[n], total_wt = 0, total_tat = 0;

//Function to find waiting time of all processes

findWaitingTime(processes, n, bt, wt);

//Function to find turn around time for all processes

findTurnAroundTime(processes, n, bt, wt, tat);

//Display processes along with all details

cout << "Processes "<< " Burst time "

<< " Waiting time " << " Turn around time\n";

// Calculate total waiting time and total turn

// around time
2
 Operating System

for (int i=0; i<n; i++)

total_wt = total_wt + wt[i];

total_tat = total_tat + tat[i];

cout << " " << i+1 << "\t\t" << bt[i] <<"\t "

<< wt[i] <<"\t\t " << tat[i] <<endl;

cout << "Average waiting time = "

<< (float)total_wt / (float)n;

cout << "\nAverage turn around time = "

<< (float)total_tat / (float)n;

// Driver code

int main()

//process id's

int processes[] = { 1, 2, 3};

int n = sizeof processes / sizeof processes[0];

//Burst time of all processes

int burst_time[] = {10, 5, 8};

3
 Operating System

findavgTime(processes, n, burst_time);

return 0;

Output:

Processes Burst time Waiting time Turn around time //The Output is Wrong please correct it

1 10 0 10

2 5 10 15

3 8 15 23

Average waiting time = 8.33333

Average turn around time = 16

EXP NO: 2 Program for File Allocation Strategies - Sequential Memory

Date:

#include <iostream>

#include <conio.h>

using namespace std;

void recurse(int files[]){

4
 Operating System

int flag = 0, startBlock, len, k;

cout << "Enter the starting block and the length of the files: ";

cin >> startBlock >> len;

for (int j=startBlock; j<(startBlock+len); j++){

if (files[j] == 0)

flag++;

if(len == flag){

for (int k=startBlock; k<(startBlock+len); k++){

if (files[k] == 0){

files[k] = 1;

cout << k <<"\t" << files[k] << endl;

if (k != (startBlock+len-1))

cout << "The file is allocated to the disk" << endl;

else

cout << "The file is not allocated to the disk" << endl;

5
 Operating System

cout << "Do you want to enter more files?" << endl;

int ch;

cout << "Press 1 for YES, 0 for NO: ";

cin >> ch;

if (ch == 1)

recurse(files);

else

exit(0);

return;

int main()

int files[50];

for(int i=0;i<50;i++)

files[i]=0;

cout << "Files Allocated are :" << endl;

recurse(files);

getch();

return 0;

6
 Operating System

EXP NO: 3
Program for File Allocation Strategies - Indexed Memory
Date:

#include <iostream>

#include <conio.h>

#include <stdlib.h>

using namespace std;

int files[50], indexBlock[50], indBlock, n;

void recurse1();

void recurse2();

void recurse1(){

cout << "Enter the index block: ";

cin >> indBlock;

if (files[indBlock] != 1){

cout << "Enter the number of blocks and the number of files needed for the index " << indBlock << " on the disk:
";

cin >> n;

}
7
 Operating System

else{

cout << indBlock << " is already allocated" << endl;

recurse1();

recurse2();

void recurse2(){

int flag = 0;

for (int i=0; i<n; i++){

cin >> indexBlock[i];

if (files[indexBlock[i]] == 0)

flag++;

if (flag == n){

for (int j=0; j<n; j++){

files[indexBlock[j]] = 1;

cout << "Allocated" << endl;

8
 Operating System

cout << "File Indexed" << endl;

for (int k=0; k<n; k++){

cout << indBlock << " ------> " << indexBlock[k] << ": " << files[indexBlock[k]] << endl;

else{

cout << "File in the index is already allocated" << endl;

cout << "Enter another indexed file" << endl;

recurse2();

cout << "Do you want to enter more files?" << endl;

cout << "Enter 1 for Yes, Enter 0 for No: ";

int ch;

cin >> ch;

if (ch == 1)

recurse1();

else

exit(0);

return;

9
 Operating System

int main()

for(int i=0;i<50;i++)

files[i]=0;

recurse1();

return 0;

10
 Operating System

EXP NO: 4
Program to simulate the following contiguous memory allocation techniques
Date: Worst-fit

#include<bits/stdc++.h>

using namespace std;

// Function to allocate memory to blocks as per worst fit

// algorithm

void worstFit(int blockSize[], int m, int processSize[],

int n)

// Stores block id of the block allocated to a

// process

int allocation[n];

// Initially no block is assigned to any process

memset(allocation, -1, sizeof(allocation));

// pick each process and find suitable blocks

11
 Operating System

// according to its size ad assign to it

for (int i=0; i<n; i++)

// Find the best fit block for current process

int wstIdx = -1;

for (int j=0; j<m; j++)

if (blockSize[j] >= processSize[i])

if (wstIdx == -1)

wstIdx = j;

else if (blockSize[wstIdx] < blockSize[j])

wstIdx = j;

// If we could find a block for current process

if (wstIdx != -1)

12
 Operating System

// allocate block j to p[i] process

allocation[i] = wstIdx;

// Reduce available memory in this block.

blockSize[wstIdx] -= processSize[i];

cout << "\nProcess No.\tProcess Size\tBlock no.\n";

for (int i = 0; i < n; i++)

cout << " " << i+1 << "\t\t" << processSize[i] << "\t\t";

if (allocation[i] != -1)

cout << allocation[i] + 1;

else

cout << "Not Allocated";

cout << endl;

13
 Operating System

// Driver code

int main() {

int blockSize[] = {100, 500, 200, 300, 600};

int processSize[] = {212, 417, 112, 426};

int m = sizeof(blockSize)/sizeof(blockSize[0]);

int n = sizeof(processSize)/sizeof(processSize[0]);

worstFit(blockSize, m, processSize, n);

return 0 ; }

Output
Process No. Process Size Block no.
1 212 5
2 417 2
3 112 5
4 426 Not Allocated

EXP NO: 5
Program to simulate the following contiguous memory allocation techniques First-
Date: fit

#include<bits/stdc++.h>

14
 Operating System

using namespace std;

// Function to allocate memory to

// blocks as per First fit algorithm

void firstFit(int blockSize[], int m,

int processSize[], int n)

// Stores block id of the

// block allocated to a process

int allocation[n];

// Initially no block is assigned to any process

memset(allocation, -1, sizeof(allocation));

// pick each process and find suitable blocks

// according to its size ad assign to it

for (int i = 0; i < n; i++)

15
 Operating System

for (int j = 0; j < m; j++)

if (blockSize[j] >= processSize[i])

// allocate block j to p[i] process

allocation[i] = j;

// Reduce available memory in this block.

blockSize[j] -= processSize[i];

break;

cout << "\nProcess No.\tProcess Size\tBlock no.\n";

for (int i = 0; i < n; i++)

16
 Operating System

cout << " " << i+1 << "\t\t"

<< processSize[i] << "\t\t";

if (allocation[i] != -1)

cout << allocation[i] + 1;

else

cout << "Not Allocated";

cout << endl;

// Driver code

int main()

int blockSize[] = {100, 500, 200, 300, 600};

int processSize[] = {212, 417, 112, 426};

int m = sizeof(blockSize) / sizeof(blockSize[0]);

int n = sizeof(processSize) / sizeof(processSize[0]);

17
 Operating System

firstFit(blockSize, m, processSize, n);

return 0 ;

Output :

Process No. Process Size Block no.

1 212 2
2 417 5
3 112 2
4 426 Not Allocated

EXP NO: 6
Program for bankers algorithm
Date:

#include<iostream>
using namespace std;

// Number of processes
const int P = 5;

// Number of resources
const int R = 3;

// Function to find the need of each process

void calculateNeed(int need[P][R], int maxm[P][R],
int allot[P][R])
18
 Operating System

{
// Calculating Need of each P
for (int i = 0 ; i < P ; i++)
for (int j = 0 ; j < R ; j++)

// Need of instance = maxm instance -

// allocated instance
need[i][j] = maxm[i][j] - allot[i][j];
}

// Function to find the system is in safe state or not

bool isSafe(int processes[], int avail[], int maxm[][R],

int allot[][R])

int need[P][R];

// Function to calculate need matrix

calculateNeed(need, maxm, allot);

// Mark all processes as infinish

bool finish[P] = {0};

// To store safe sequence

int safeSeq[P];

19
 Operating System

// Make a copy of available resources

int work[R];

for (int i = 0; i < R ; i++)

work[i] = avail[i];

// While all processes are not finished

// or system is not in safe state.

int count = 0;

while (count < P)

// Find a process which is not finish and

// whose needs can be satisfied with current

// work[] resources.

bool found = false;

for (int p = 0; p < P; p++)

// First check if a process is finished,

20
 Operating System

// if no, go for next condition

if (finish[p] == 0)

// Check if for all resources of

// current P need is less

// than work

int j;

for (j = 0; j < R; j++)

if (need[p][j] > work[j])

break;

// If all needs of p were satisfied.

if (j == R)

// Add the allocated resources of

// current P to the available/work

// resources i.e.free the resources

for (int k = 0 ; k < R ; k++)

21
 Operating System

work[k] += allot[p][k];

// Add this process to safe sequence.

safeSeq[count++] = p;

// Mark this p as finished

finish[p] = 1;

found = true;

// If we could not find a next process in safe

// sequence.

if (found == false)

cout << "System is not in safe state";

22
 Operating System

return false;

// If system is in safe state then

// safe sequence will be as below

cout << "System is in safe state.\nSafe"

" sequence is: ";

for (int i = 0; i < P ; i++)

cout << safeSeq[i] << " ";

return true;

// Driver code

int main()

int processes[] = {0, 1, 2, 3, 4};

23
 Operating System

// Available instances of resources

int avail[] = {3, 3, 2};

// Maximum R that can be allocated

// to processes

int maxm[][R] = {{7, 5, 3},

{3, 2, 2},

{9, 0, 2},

{2, 2, 2},

{4, 3, 3}};

// Resources allocated to processes

int allot[][R] = {{0, 1, 0},

{2, 0, 0},

{3, 0, 2},

{2, 1, 1},

{0, 0, 2}};

24
 Operating System

// Check system is in safe state or not

isSafe(processes, avail, maxm, allot);

return 0;

Output:
System is in safe state.
Safe sequence is: 1 3 4 0 2

25
 Operating System

EXP NO: 7
Program to simulate disk scheduling algorithms SCAN
Date:

#include<bits/stdc++.h>
using namespace std;
int main(){
int i,j,k,n,m,sum=0,x,y,h;
cout<<"Enter the size of disk\n";
cin>>m;
cout<<"Enter number of requests\n";
cin>>n;
cout<<"Enter the requests\n";
vector <int> a(n),b;
for(i=0;i<n;i++){
cin>>a[i];
}
for(i=0;i<n;i++){
if(a[i]>m){
cout<<"Error, Unknown position "<<a[i]<<"\n";
return 0;
}
}
cout<<"Enter the head position\n";
cin>>h;
int temp=h;
a.push_back(h);
a.push_back(m);
a.push_back(0);
sort(a.begin(),a.end());
for(i=0;i<a.size();i++){
if(h==a[i])
break;
}
k=i;
26
 Operating System

if(k<n/2){
for(i=k;i<a.size();i++){
b.push_back(a[i]);
}
for(i=k-1;i>=0;i--){
b.push_back(a[i]);
}
}
else{
for(i=k;i>=0;i--){
b.push_back(a[i]);
}
for(i=k+1;i<a.size();i++){
b.push_back(a[i]);
}
}
temp=b[0];
cout<<temp;
for(i=1;i<b.size();i++){
cout<<" -> "<<b[i];
sum+=abs(b[i]-temp);
temp=b[i];
}
cout<<'\n';
cout<<"Total head movements = "<< sum<<'\n';
cout<<"Average head movement = "<<(float)sum/n<<'\n';
return 0;
}
OUTPUT:

Enter the size of disk

199
Enter number of requests
8
Enter the requests
98 183 37 122 14 124 65 67
Enter the head position
53
53 -> 65 -> 67 -> 98 -> 122 -> 124 -> 183 -> 199 -> 37 -> 14 -> 0
Total head movements = 345
Average head movement = 43.125

27
 Operating System

EXP NO: 8
Program for Page Replacement Algorithms LRU
Date:

#include<bits/stdc++.h>

using namespace std;

// Function to find page faults using indexes

28
 Operating System

int pageFaults(int pages[], int n, int capacity)

// To represent set of current pages. We use

// an unordered_set so that we quickly check

// if a page is present in set or not

unordered_set<int> s;

// To store least recently used indexes

// of pages.

unordered_map<int, int> indexes;

// Start from initial page

int page_faults = 0;

for (int i=0; i<n; i++)

// Check if the set can hold more pages

if (s.size() < capacity)

29
 Operating System

// Insert it into set if not present

// already which represents page fault

if (s.find(pages[i])==s.end())

s.insert(pages[i]);

// increment page fault

page_faults++;

// Store the recently used index of

// each page

indexes[pages[i]] = i;

// If the set is full then need to perform lru

// i.e. remove the least recently used page

// and insert the current page

else

30
 Operating System

// Check if current page is not already

// present in the set

if (s.find(pages[i]) == s.end())

// Find the least recently used pages

// that is present in the set

int lru = INT_MAX, val;

for (auto it=s.begin(); it!=s.end(); it++)

if (indexes[*it] < lru)

lru = indexes[*it];

val = *it;

// Remove the indexes page

31
 Operating System

s.erase(val);

// insert the current page

s.insert(pages[i]);

// Increment page faults

page_faults++;

// Update the current page index

indexes[pages[i]] = i;

return page_faults;

// Driver code

32
 Operating System

int main()

int pages[] = {7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2};

int n = sizeof(pages)/sizeof(pages[0]);

int capacity = 4;

cout << pageFaults(pages, n, capacity);

return 0;

Output:
6

EXP NO: 9
Program to simulate producer-consumer problem using semaphores
Date:

#include<bits/stdc++.h>

33
 Operating System

#include<pthread.h>

#include<semaphore.h>

#include <unistd.h>

using namespace std;

// Declaration

int r1,total_produced=0,total_consume=0;

// Semaphore declaration

sem_t notEmpty;

// Producer Section

void* produce(void *arg){

while(1){

cout<<"Producer produces item."<<endl;

cout<<"Total produced = "<<++total_produced<<

" Total consume = "<<total_consume*-1<<endl;

sem_post(¬Empty);

34
 Operating System

sleep(rand()%100*0.01);

// Consumer Section

void* consume(void *arg){

while(1){

sem_wait(¬Empty);

cout<<"Consumer consumes item."<<endl;

cout<<"Total produced = "<<total_produced<<

" Total consume = "<<(--total_consume)*-1<<endl;

sleep(rand()%100*0.01);

int main(int argv,char *argc[]){

// thread declaration

35
 Operating System

pthread_t producer,consumer;

// Declaration of attribute......

pthread_attr_t attr;

// semaphore initialization

sem_init(¬Empty,0,0);

// pthread_attr_t initialization

pthread_attr_init(&attr);

pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_JOINABLE);

// Creation of process

r1=pthread_create(&producer,&attr,produce,NULL);

if(r1){

cout<<"Error in creating thread"<<endl;

exit(-1);

36
 Operating System

r1=pthread_create(&consumer,&attr,consume,NULL);

if(r1){

cout<<"Error in creating thread"<<endl;

exit(-1);

// destroying the pthread_attr

pthread_attr_destroy(&attr);

// Joining the thread

r1=pthread_join(producer,NULL);

if(r1){

cout<<"Error in joining thread"<<endl;

exit(-1);

r1=pthread_join(consumer,NULL);

37
 Operating System

if(r1){

cout<<"Error in joining thread"<<endl;

exit(-1);

// Exiting thread

pthread_exit(NULL);

return 0;

EXP NO: 10
Program to simulate the concept of Dining-Philosophers problem.
Date:

38
 Operating System

#include <bits/stdc++.h>

#include <pthread.h>

#include <unistd.h>

using namespace std;

#define N 10

#define THINKING 2

#define HUNGRY 1

#define EATING 0

#define LEFT (phnum + 4) % N

#define RIGHT (phnum + 1) % N

// Philosopher index

int phil[N];

int times = 200;

class monitor {

39
 Operating System

// state of the philosopher

int state[N];

// Philosopher condition variable

pthread_cond_t phcond[N];

// mutex variable for synchronization

pthread_mutex_t condLock;

public:

// Test for the desired condition

// i.e. Left and Right philosopher are not reading

void test(int phnum)

if (state[(phnum + 1) % 5] != EATING

and state[(phnum + 4) % 5] != EATING

and state[phnum] == HUNGRY) {

40
 Operating System

state[phnum] = EATING;

pthread_cond_signal(&phcond[phnum]);

// Take Fork function

void take_fork(int phnum)

pthread_mutex_lock(&condLock);

// Indicates it is hungry

state[phnum] = HUNGRY;

// test for condition

test(phnum);

41
 Operating System

// If unable to eat.. wait for the signal

if (state[phnum] != EATING) {

pthread_cond_wait(&phcond[phnum], &condLock);

cout << "Philosopher " << phnum << " is Eating"

<< endl;

pthread_mutex_unlock(&condLock);

// Put Fork function

void put_fork(int phnum)

pthread_mutex_lock(&condLock);

// Indicates that I am thinking

state[phnum] = THINKING;

42
 Operating System

test(RIGHT);

test(LEFT);

pthread_mutex_unlock(&condLock);

// constructor

monitor()

for (int i = 0; i < N; i++) {

state[i] = THINKING;

for (int i = 0; i < N; i++) {

pthread_cond_init(&phcond[i], NULL);

43
 Operating System

pthread_mutex_init(&condLock, NULL);

// destructor

~monitor()

for (int i = 0; i < N; i++) {

pthread_cond_destroy(&phcond[i]);

pthread_mutex_destroy(&condLock);

// Global Object of the monitor

phil_object;

44
 Operating System

void* philosopher(void* arg)

int c = 0;

while (c < times) {

int i = *(int*)arg;

sleep(1);

phil_object.take_fork(i);

sleep(0.5);

phil_object.put_fork(i);

c++;

int main()

// Declaration...

45
 Operating System

pthread_t thread_id[N];

pthread_attr_t attr;

// Initialization...

pthread_attr_init(&attr);

pthread_attr_setdetachstate(&attr,

PTHREAD_CREATE_JOINABLE);

for (int i = 0; i < N; i++) {

phil[i] = i;

// Creating...

for (int i = 0; i < N; i++) {

pthread_create(&thread_id[i], &attr, philosopher,

&phil[i]);

cout << "Philosopher " << i + 1 << " is thinking..."

<< endl;

46
 Operating System

// Joining....

for (int i = 0; i < N; i++) {

pthread_join(thread_id[i], NULL);

// Destroying

pthread_attr_destroy(&attr);

pthread_exit(NULL);

return 0;

47