lOMoAR cPSD| 30415125

EXPERIMENT – 4
Objective - Implement file storage allocation technique:
i. Contiguous(using array) ii.
Linked –list(using linked-list) iii.
Indirect allocation (indexing)
Theory –

1. Contiguous Allocation
About Contiguous allocation technique:
In this scheme, each file occupies a contiguous set of blocks on the disk. For example, if a file requires
n blocks and is given a block b as the starting location, then the blocks assigned to the file will be: b,
b+1, b+2,……b+n-1. This means that given the starting block address and the length of the file (in
terms of blocks required), we can determine the blocks occupied by the file.
The directory entry for a file with contiguous allocation contains Address
of starting block
Length of the allocated portion.

4(i). Example program for Contiguous(using array)file storage allocation technique

#include<stdio.h>
struct filep { int
id; int start; int
count;
};
typedef struct filep files; int
main() {
int disk[100]; int
i,j,k;
for(i=0;i<100;i++)
disk[i]=-1;
files f[3]; for(i=0;i
< 3;i++) {
f[i].id=i;
printf("enter the number of blocks for file : %d", i);
scanf("%d", &f[i].count);
} int flag =
0;
for(i=0;i<3;i++) {
flag=0;
for(j=0;j<100;j++){
if(disk[j] == -1) {
for(k=j;k< j+f[i].count && disk[k] == -1;k++) {
flag++;
printf("\n flag for file %d : %d\n", i, flag);
}
if(flag == f[i].count) {
for(k=j;k< j+f[i].count;k++) {
f[i].start = j;
disk[k]=f[i].id;
}

Downloaded by Arman Ali (a75215710@gmail.com)

 lOMoAR cPSD| 30415125

j=j+f[i].count;
break;
}
else {
j=j+flag;
flag=0;
}}
if(j==99 && flag == 0)
printf("\n disk is full \n");
}}
printf("\n here is the disk allocation details \n");
for(i=0;i<100;i++) printf("%d ", disk[i]); return
0;
}
Input: Program 4(i):
Disk Size = 100 (Block (all of equal size))

File ID Block_Count
File 0 5
File 1 3
File 2 2

Output:
here is the disk allocation details
0 0 0 0 0 1 1 1 2 2 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 1
-1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -
1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1

2. Linked List
About Linked List Allocation technique:
In this scheme, each file is a linked list of disk blocks which need not be contiguous. The disk blocks
can be scattered anywhere on the disk.
The directory entry contains a pointer to the starting and the ending file block. Each block contains a
pointer to the next block occupied by the file.
The file ‘jeep’ in following image shows how the blocks are randomly distributed. The last block
(25) contains -1 indicating a null pointer and does not point to any other block.

Downloaded by Arman Ali (a75215710@gmail.com)

 lOMoAR cPSD| 30415125

Figure: Linked List file allocation technique

Example program for file storage allocation technique (Linked List Allocation)
#include<stdio.h> #include<stdlib.h> struct file{
int id; int
block;
struct file *next_block;
};
typedef struct file f; int main(){
f *file1, *temp, *temp2;
int i=1,j, count; printf("enter the number of
blocks for file : %d", i); scanf("%d", &count);
for(j=0;j<count;j++){
if(j==0){
temp=(f*)malloc(sizeof(f));
temp->id=i;
temp->block=j;
temp->next_block=NULL;
file1=temp;
printf("%d\t", i);
}
else{
temp=file1;
while ( temp->next_block != NULL)
temp=temp->next_block;
temp2=(f*)malloc(sizeof(f));
temp2->id=i;
temp2->block=j; temp2-
>next_block=NULL; temp-
>next_block = temp2;
printf("%d\t", i);
}
}
printf("\n Here is the disk allocation for file : \n");
temp=file1; while(temp!=NULL){
printf("file id: %d\t block number: %d\t block address %d\n", temp->id, temp-
>block,(int)temp);
temp=temp->next_block;
} return
0;}
Input:

File ID Block_Count
File 1 5

Output:
Here is the disk allocation for file :
file id: 1 block number: 0 block address 38287408
file id: 1 block number: 1 block address 38287440
file id: 1 block number: 2 block address 38287472

Downloaded by Arman Ali (a75215710@gmail.com)

 lOMoAR cPSD| 30415125

file id: 1 block number: 3 block address 38287504

file id: 1 block number: 4 block address 38287536
file id: 1 block number: 5 block address 38287568

3. Indirect Allocation
About Indirect allocation (indexing) technique:
In this scheme, a special block known as the Index block contains the pointers to all the blocks occupied
by a file. Each file has its own index block. The ith entry in the index block contains the disk address of
the ith file block. The directory entry contains the address of the index block as shown in the image:

Figure: Indirect (index) file allocation technique

Example program for file storage allocation technique (Indirect (index))
#include<stdio.h> #include<stdlib.h>
struct file{
int id; int
block;
struct file *next_block;
}; typedef struct
file f;
int main(){
f *files[3], *temp, *temp2;
int count, i, j, id; for(i=0;i<3;i++){
printf("enter the number of blocks for file : %d", i);
scanf("%d", &count);
for(j=0;j<count;j++) {
if(j==0){
temp=(f*)malloc(sizeof(f));
temp->id=i;
temp->block=j;
temp->next_block=NULL;
files[i]=temp;
printf("%d\t", i);
}
else{
temp=files[i];
while ( temp->next_block != NULL)
temp=temp->next_block;
temp2=(f*)malloc(sizeof(f));

Downloaded by Arman Ali (a75215710@gmail.com)

 lOMoAR cPSD| 30415125

temp2->id=i; temp2-
>block=j;
temp2->next_block=NULL; temp-
>next_block = temp2;
printf("%d\t", i);
}}}
temp=files[id]; while(temp!=NULL){
printf("file id: %d\t block number: %d\t block address %d\n", temp->id, temp-
>block,(int)temp);
temp=temp->next_block;
}
return 0;
}
Input: Program 4(iii):

File ID Block_Count
File 0 5
File 1 4
File 2 6
Output:
disk allocation using index as file id
file id: 0 block number: 0 block address 35997744
file id: 0 block number: 1 block address 35997776
file id: 0 block number: 2 block address 3599780
file id: 0 block number: 3 block address 35997840
file id: 0 block number: 4 block address 35997872

file id: 1 block number: 0 block address 35997904

file id: 1 block number: 1 block address 35997936
file id: 1 block number: 2 block address 35997968
file id: 1 block number: 3 block address 35998000

file id: 2 block number: 0 block address 35998032

file id: 2 block number: 1 block address 35998064
file id: 2 block number: 2 block address 35998096
file id: 2 block number: 3 block address 35998128
file id: 2 block number: 4 block address 35998160
file id: 2 block number: 5 block address 35998192

Downloaded by Arman Ali (a75215710@gmail.com)

 lOMoAR cPSD| 30415125

EXPERIMENT – 5
Objective - Implementation of contiguous allocation techniques:
i. Worst-Fit
ii. Best-Fit
iii. First-Fit

Theory –

1. Worst Fit
Worst Fit Allocate the process to the partition which is the largest sufficient among the freely
available partitions available in the main memory.
Algorithm
Step 1. Input the total number of blocks and their size.
Step 2. Input the total number of processes and their size.
Step 3. For each process in list
Find free block having max size and greater than process size Allocate
block to process

Example program for implementation of contiguous allocation techniques: Worst-Fit

#include<stdio.h> #include<stdlib.h> int disk[20]; struct blocks{
int bid;
int size; int
index;
}block; struct
processs{
int pid;
int size; int
flag; struct blocks
b;
int fragment;
}process;
int main(){ int nb,
np, i , j;
int disk_index=0;
printf(" Total disk size is 50 \n");
printf(" enter numebr of blocks: ");
scanf("%d", &nb);
struct blocks bls[nb], temp;
for(i=0;i<nb;i++) {
bls[i].bid=i;
printf("enter the size of block %d ", i);
scanf("%d", &bls[i].size);
bls[i].index=disk_index;
disk_index=disk_index+bls[i].size;

}
printf(" enter numebr of process: ");
scanf("%d",&np);

Downloaded by Arman Ali (a75215710@gmail.com)

 lOMoAR cPSD| 30415125

struct processs ps[np];

for(i=0;i<np;i++){
ps[i].pid=i;
printf("enter the size of process %d ", i);
scanf("%d", &ps[i].size);
ps[i].flag=-1;

}
for(i=0;i<nb-1;i++){
for(j=i+1;j<nb;j++){
if(bls[j].size > bls[i].size){
temp.bid = bls[j].bid;
temp.size = bls[j].size;
temp.index = bls[j].index;
bls[j].bid = bls[i].bid;
bls[j].size = bls[i].size;
bls[j].index = bls[i].index;
bls[i].bid = temp.bid;
bls[i].size = temp.size;
bls[i].index = temp.index;
}}}
for(i=0;i<np;i++){
if(i >= nb || bls[i].size < ps[i].size)
printf("\n no block is available for the process \n");
else
ps[i].b=bls[i];
}
printf(" \n now process block allocation list is \n");
for(i=0;i<np;i++){
printf(" process id: %d process size %d block id %d free space %d\n", ps[i].pid, ps[i].size,
ps[i].b.bid, ps[i].b.size-ps[i].size);
} return
0;
}
Input: Program 5(i):
Block ID Block_size
Block 0 5
Block 1 4
Block 2 8
Block 3 3

Process ID Process_size
Process 0 3
Process 1 2
Process 2 4

Output:
now process block allocation list is

Downloaded by Arman Ali (a75215710@gmail.com)

 lOMoAR cPSD| 30415125

process id: 0 process size 3 block id 2 free space 5

process id: 1 process size 2 block id 0 free space 3 process
id: 2 process size 4 block id 1 free space 0

2. Best-Fit
Best Fit Allocate the process to the partition which is the first smallest sufficient partition among the
free available partition.
Algorithm
Step 1. Input the total number of blocks and their size.
Step 2. Input the total number of processes and their size.
Step 3. For each process in list
Find free block where, block_size - process _size = minimum Allocate
block to process

Example program for implementation of contiguous allocation techniques: Best-Fit

#include<stdio.h> #include<stdlib.h> int disk[20]; struct blocks{
int bid;
int size; int
index;
}block; struct
processs{
int pid;
int size; int
flag; struct blocks
b;
int fragment;
}process;
int main(){ int nb,
np, i , j;
int disk_index=0;
printf(" Total disk size is 20 \n");
printf(" enter numebr of blocks: ");
scanf("%d", &nb); struct
blocks bls[nb]; for(i=0;i<nb;i++){
bls[i].bid=i;
printf("enter the size of block %d ", i);
scanf("%d", &bls[i].size); bls[i].index=disk_index;
disk_index=disk_index+bls[i].size;
}
printf(" enter numebr of process:
"); scanf("%d",&np); struct
processs ps[np]; for(i=0;i<np;i++){
ps[i].pid=i;
printf("enter the size of process %d ", i);
scanf("%d", &ps[i].size);
ps[i].flag=-1;
}
int temp,temp2=20, bindex, pindex;
for(i=0; i<nb;i++){

Downloaded by Arman Ali (a75215710@gmail.com)

 lOMoAR cPSD| 30415125

for(j=0;j<np;j++){
temp = bls[i].size - ps[j].size;
if(temp < 0){
continue;
}
else if(temp < temp2) {
if(ps[j].flag == -1){
pindex=j;
temp2=temp;
}}}
ps[pindex].b = bls[i];
ps[pindex].flag = 1;
temp2=20;
}
printf(" \n now process block allocation list is \n");
for(i=0;i<np;i++){
printf(" process id: %d process size %d block id %d free space %d\n", ps[i].pid, ps[i].size,
ps[i].b.bid, ps[i].b.size-ps[i].size);
} return
0;
}

Input: Program 5(ii):

Block ID Blocksize
Block 0 5
Block 1 4
Block 2 8
Block 3 3

Process ID Process size

Process 0 3
Process 1 2
Process 2 4

Output:
now process block allocation list is
process id: 0 process size 3 block id 1 free space 1 process
id: 1 process size 2 block id 3 free space 1 process id: 2
process size 4 block id 0 free space 1

3. First Fit
First Fit: In the first fit, the partition is allocated which is first sufficient block from the top of Main
Memory.
Algorithm
Step 1. Input the total number of blocks and their size.
Step 2. Input the total number of processes and their size.

Downloaded by Arman Ali (a75215710@gmail.com)

 lOMoAR cPSD| 30415125

Step 3. For each process in list

Find free block where, block size > process _size
Allocate block to process

Example program for implementation of contiguous allocation techniques: First-Fit

#include<stdio.h> #include<stdlib.h> int disk[20]; struct blocks{
int bid;
int size; int
index;
int status;
}block;
struct processs{
int pid;
int size; int
flag; struct blocks
b;
int fragment;
}process;
int main(){ int nb,
np, i , j;
int disk_index=0;
printf(" Total disk size is 50 \n");
printf(" enter numebr of blocks: ");
scanf("%d", &nb);
struct blocks bls[nb], temp;
for(i=0;i<nb;i++){
bls[i].bid=i;
printf("enter the size of block %d ", i);
scanf("%d", &bls[i].size); bls[i].index=disk_index;
disk_index=disk_index+bls[i].size;
bls[i].status = -1;
}
printf(" enter numebr of process: ");
scanf("%d",&np);
struct processs ps[np];
for(i=0;i<np;i++) {
ps[i].pid=i;
printf("enter the size of process %d ", i);
scanf("%d", &ps[i].size);
ps[i].flag=-1;
}
for(i=0;i<np;i++){
for(j=0;j<nb;j++) {
if(bls[j].size > ps[i].size && bls[j].status ==-1) {
ps[i].b=bls[j];
bls[j].status = 1;
break;
}}}

Downloaded by Arman Ali (a75215710@gmail.com)

 lOMoAR cPSD| 30415125

printf(" \n now process block allocation list is \n");

for(i=0;i<np;i++){
printf(" process id: %d process size %d block id %d free space %d\n", ps[i].pid,
ps[i].size, ps[i].b.bid, ps[i].b.size-ps[i].size);
} return
0;
}

Input: Program 5(iii):

Block ID Block_size
Block 0 5
Block 1 4
Block 2 8
Block 3 3

Process ID Process_size
Process 0 3
Process 1 2
Process 2 4

Output:
now process block allocation list is process id: 0
process size 4 block id 0 free space 1 process id: 1
process size 2 block id 1 free space 2
process id: 2 process size 3 block id 2 free space 5

Downloaded by Arman Ali (a75215710@gmail.com)

 lOMoAR cPSD| 30415125

EXPERIMENT – 6
Objective – Calculation of Internal and External fragmentation

i. Free space list of blocks from system

ii. List process file from the system

Theory –

1. Fres space list of blocks from system External

Fragmentation:
External fragmentation happens when there’s a sufficient quantity of area within the memory to satisfy
the memory request of a method. However, the process’s memory request cannot be fulfilled because
the memory offered is during a non-contiguous manner. Either you apply first-fit or best-fit memory
allocation strategy it’ll cause external fragmentation.

Figure. External Fragmentation in System

Example program for Free space list of blocks from system
#include<stdio.h>
#include<stdlib.h> int
disk[20];
struct blocks{
int bid;
int size; int
index;
int status;
}block; struct
processs{ int pid;
int size; int
flag; struct blocks
b;
int fragment;
}process;
int main(){ int nb,
np, i , j;
int disk_index=0;
printf(" Total disk size is 50 \n");
printf(" enter numebr of blocks: ");
scanf("%d", &nb); struct
blocks bls[nb], temp; for(i=0;i<nb;i++){
bls[i].bid=i;

Downloaded by Arman Ali (a75215710@gmail.com)

 lOMoAR cPSD| 30415125

printf("enter the size of block %d ", i);

scanf("%d", &bls[i].size);
bls[i].index=disk_index;
disk_index=disk_index+bls[i].size;
bls[i].status = -1;
}
printf(" enter numebr of process:
"); scanf("%d",&np); struct
processs ps[np]; for(i=0;i<np;i++){
ps[i].pid=i;
printf("enter the size of process %d ", i);
scanf("%d", &ps[i].size);
ps[i].flag=-1;
}
for(i=0;i<np;i++){
for(j=0;j<nb;j++){
if(bls[j].size > ps[i].size && bls[j].status ==-1){
ps[i].b=bls[j];
bls[j].status = 1;
break;
}}}
printf(" \n now Free space list of blocks is \n"); int
free=0;
for(i=0;i<nb;i++)
if(bls[i].status == -1){
printf(" Block id: %d Block size %d block index %d \n", bls[i].bid,
bls[i].size, bls[i].index);
free= free + bls[i].size;
}}
printf(" \n Total external free space is: %d \n", free); return
0;
}
Input: Program 6:
Disk size = 20

Block ID Blocksize
Block 0 5
Block 1 4
Block 2 8
Block 3 3

Process ID Process size

Process 0 4
Process 1 6
Process 2 2

Output:

Downloaded by Arman Ali (a75215710@gmail.com)

 lOMoAR cPSD| 30415125

now Free space list of blocks is Block

id: 2 Block size 3 block index 9
Total external free space is: 3
2. List process file from the system
Internal Fragmentation:
Internal fragmentation happens when the memory is split into mounted sized blocks. Whenever, a
method request for the memory, the mounted sized block is allotted to the method. Just in case, the
memory allotted to the method is somewhat larger than the memory requested, then the distinction
between allotted and requested memory is that the internal fragmentation.

Figure. Internal Fragmentation

Example program for List process file from the system
#include<stdio.h>
#include<stdlib.h> int
disk[20];
struct blocks{
int bid;
int size; int
index;
int status;
}block; struct
processs{
int pid;
int size; int
flag; struct blocks
b;
int fragment;
}process;
int main(){ int nb,
np, i , j;
int disk_index=0;
printf(" Total disk size is 50 \n");
printf(" enter numebr of blocks: ");
scanf("%d", &nb);
struct blocks bls[nb], temp;
for(i=0;i<nb;i++){
bls[i].bid=i;

Downloaded by Arman Ali (a75215710@gmail.com)

 lOMoAR cPSD| 30415125

printf("enter the size of block %d ", i);

scanf("%d", &bls[i].size); bls[i].index=disk_index;
disk_index=disk_index+bls[i].size;
bls[i].status = -1;
}
printf(" enter numebr of process: ");
scanf("%d",&np);
struct processs ps[np];
for(i=0;i<np;i++){
ps[i].pid=i;
printf("enter the size of process %d ", i);
scanf("%d", &ps[i].size);
ps[i].flag=-1;
}
for(i=0;i<np;i++){
for(j=0;j<nb;j++){
if(bls[j].size > ps[i].size && bls[j].status ==-1){
ps[i].b=bls[j];
bls[j].status = 1;
break;
}}}
printf(" \n now process block allocation list is \n"); int t_free=0; for(i=0;i<np;i++){ printf("
process id: %d process size %d block id %d free space %d\n", ps[i].pid, ps[i].size, ps[i].b.bid,
ps[i].b.size-ps[i].size);
t_free = t_free + (ps[i].b.size-ps[i].size);
}
printf(" \n Total internal fragmentation space is: %d \n", t_free); return
0;
}

Input: Program 6(ii):

Block ID Block_size
Block 0 5
Block 1 4
Block 2 8
Block 3 3
Process ID Process_size
Process 0 3
Process 1 2
Process 2 4

Output:
now process block allocation list is process id: 0
process size 4 block id 0 free space 1 process id: 1
process size 2 block id 1 free space 2
process id: 2 process size 3 block id 2 free space 5

Total internal fragmentation space is: 8

Downloaded by Arman Ali (a75215710@gmail.com)

 lOMoAR cPSD| 30415125

EXPERIMENT – 7
Objective – Implementation of compaction for the continually changing memory layout and
calculate total movement of data

Theory –
Memory compaction
The longstanding memory fragmentation problem has been covered many times in these pages. In
short: as the system runs, pages tend to be scattered between users, making it hard to find groups of
physically-contiguous pages when they are needed. Much work has gone into avoiding the need for
higher-order (multi-page) memory allocations whenever possible, with the result that most kernel
functionality is not hurt by page fragmentation. But there are still situations where higher-order
allocations are needed; code which needs such allocations can fail on a fragmented system.

Example:

Figure: Memory status (where red part are the

occupied block and white cells free memory)

Figure: Move the free space one side and occupied

space on another side

Figure: Memory after compaction

Example program for Implementation of compaction for the continually changing memory
layout and calculate total movement of data
#include<stdio.h>
#include<stdlib.h
> int disk[20];
struct blocks{
int bid;
int size;
int index;
int status;
}block; struct
processs{
int pid;
int size;
int flag;
struct blocks
b;
int fragment;

Downloaded by Arman Ali (a75215710@gmail.com)

 lOMoAR cPSD| 30415125

}process;
int main(){ int nb,
np, i , j;
int disk_index=0;
printf(" Total disk size is 50 \n");
printf(" enter numebr of blocks: ");
scanf("%d", &nb);
struct blocks bls[nb], temp;
for(i=0;i<nb;i++) {
bls[i].bid=i;
printf("enter the size of block %d ", i);
scanf("%d", &bls[i].size);
bls[i].index=disk_index;
disk_index=disk_index+bls[i].size;
bls[i].status = -1;
}
printf(" enter numebr of process:
"); scanf("%d",&np); struct
processs ps[np];
for(i=0;i<np;i++){
ps[i].pid=i;
printf("enter the size of process %d ", i);
scanf("%d", &ps[i].size);
ps[i].flag=-1;
}
for(i=0;i<np;i++){
for(j=0;j<nb;j++) {
if(bls[j].size > ps[i].size && bls[j].status ==-1){ ps[i].b=bls[j];
bls[j].status = 1;
break;
}}}
printf(" \n now process block allocation list is \n"); for(i=0;i<np;i++){ printf(" process id:
%d process size %d block id %d free space %d\n", ps[i].pid, ps[i].size, ps[i].b.bid,
ps[i].b.size-ps[i].size);
}
printf(" \n now Free space list of blocks is \n");
int free=0; for(i=0;i<nb;i++){
printf(" Block id: %d Block size %d block index %d \n", bls[i].bid, bls[i].size,
bls[i].index);
}
int sid, count=0;
for(i=0;i<nb-1;i++){
count = 0;
for(j=1; j<nb;j++){
if(bls[i].status == -1 && bls[j].status !=-1){
sid = bls[j].index;
bls[j].index= bls[i].index;
bls[i].index = sid;
}

Downloaded by Arman Ali (a75215710@gmail.com)

 lOMoAR cPSD| 30415125

else{
count = count +1;
i=i+count;
}
}
i=i-count;
}
printf(" \n now After compaction list of blocks is \n");
free=0; for(i=0;i<nb;i++){
if(bls[i].status == -1){
printf(" Block id: %d Block size %d New block index %d \n", bls[i].bid, bls[i].size, bls[i].index);
free= free + bls[i].size;
}
}
printf(" \n Total external free space is: %d \n",
free); return 0; }

Input: Program 7:

Block ID Block_size
Block 0 3
Block 1 8
Block 2 5
Block 3 4

Process Process_size
ID
Process 4
0
Process 2
1

Output:
now process block allocation list is

process id: 0 process size 4 block id 1 free space 4 process

id: 1 process size 4 block id 2 free space 1

now Free space list of blocks is Block

id: 0 Block size 3 block index 0
Block id: 1 Block size 8 block index 3
Block id: 2 Block size 5 block index 11
Block id: 3 Block size 4 block index 16
now After compaction list of blocks is Block
id: 0 Block size 3 New block index 11
Block id: 3 Block size 4 New block index 16
Total external free space is: 7

Downloaded by Arman Ali (a75215710@gmail.com)

 lOMoAR cPSD| 30415125

EXPERIMENT – 8
Objective – Implementation of Resource Allocating Graph (RAG).

Theory – Resource Allocation Graph (RAG)

As Banker’s algorithm using some kind of table like allocation, request, available all that thing to
understand what is the state of the system. Similarly, if you want to understand the state of the
system instead of using those table, actually tables are very easy to represent and understand it, but
then still you could even represent the same information in the graph. That graph is called Resource
Allocation Graph (RAG).
So, resource allocation graph is explained to us what is the state of the system in terms of processes
and resources. Like how many resources are available, how many are allocated and what is the
request of each process. Everything can be represented in terms of the diagram. One of the
advantages of having a diagram is, sometimes it is possible to see a deadlock directly by using RAG,
but then you might not be able to know that by looking at the table. But the tables are better if the
system contains lots of process and resource and Graph is better if the system contains less number
of process and resource.
We know that any graph contains vertices and edges. So RAG also contains vertices and edges. In
RAG vertices are two type –
1. Process vertex – Every process will be represented as a process vertex.Generally, the process will
be represented with a circle.
2. Resource vertex – Every resource will be represented as a resource vertex.

Figure: Resource Allocation Graph

8. Example program for Implementation of resource allocation graph RAG) #include<stdio.h>
int main(){
int np, nr, temp, temp1;
printf("enter number of resources:
"); scanf("%d", &nr);
printf("enter number of processs: ");
scanf("%d", &np); int
rag[nr+np][nr+np]; int i, j;
for(i=0;i<np+nr;i++) {
for(j=0; j<np+nr;j++) {
rag[i][j]=0;
}
}
for(i=0;i<np;i++){
printf("enter the number of resources process %d, holding", i);
scanf("%d", &temp);
for(j=0; j<temp;j++){

Downloaded by Arman Ali (a75215710@gmail.com)

 lOMoAR cPSD| 30415125

printf("enter the ressorce number process %d holding: ", j);

scanf("%d", &temp1);
rag[np+temp1][i]=1;
}
printf("enter the number of resources process %d, requesting", i);
scanf("%d", &temp);
for(j=0; j<temp;j++){
printf("enter the ressorce number process %d requesting: ", i);
scanf("%d", &temp1);
rag[i][np+temp1]=1;
}
}
for(i=0;i<np+nr;i++){
for(j=0; j<np+nr;j++){
printf("%d ", rag[i][j]);
}
printf("\n ");
}
return 0;
}

Input: Program 8:

Process ID Resource Handling Resource Requesting

Process 0 R0 R2
Process 1 R1 R0
Process 2 R2 R1

Output:
P0 P1 P2 R0 R1 R2 P0
000001
P1 0 0 0 1 0 0
P2 0 0 0 0 1 0
R0 1 00 0 0 0
R1 0 1 0 0 0 0
R2 0 0 1 0 0 0

Downloaded by Arman Ali (a75215710@gmail.com)

 lOMoAR cPSD| 30415125

EXPERIMENT – 9
Objective – Implementation of Banker’s Algorithm
Theory – Banker’s Algorithm
The Banker’s algorithm is a resource allocation and deadlock avoidance algorithm that tests for safety by
simulating the allocation for predetermined maximum possible amounts of all resources, then makes an
“sstate” check to test for possible activities, before deciding whether allocation should be allowed to continue.
Following Data structures are used to implement the Banker’s Algorithm:
Let ‘n’ be the number of processes in the system and ‘m’ be the number of resources types.
Available:
• It is a 1-d array of size ‘m’ indicating the number of available resources of each type.
• Available[ j ] = k means there are ‘k’ instances of resource type Rj Max:
• It is a 2-d array of size ‘n*m’ that defines the maximum demand of each process in a system.
• Max[ i, j ] = k means process Pi may request at most ‘k’ instances of resource type Rj.
Allocation:
• It is a 2-d array of size ‘n*m’ that defines the number of resources of each type currently
allocated to each process.
• Allocation[ i, j ] = k means process Pi is currently allocated ‘k’ instances of resource type Rj
Need :
• It is a 2-d array of size ‘n*m’ that indicates the remaining resource need of each process.
• Need [ i, j ] = k means process Pi currently need ‘k’ instances of resource type Rj for its
execution.
• Need [ i, j ] = Max [ i, j ] – Allocation [ i, j ]

Allocationi specifies the resources currently allocated to process Pi and Needi specifies the additional
resources that process Pi may still request to complete its task.
Banker’s algorithm consists of Safety algorithm and Resource request algorithm.
Safety Algorithm
1) Let Work and Finish be vectors of length ‘m’ and ‘n’ respectively.
Initialize: Work = Available
Finish[i] = false; for i=1, 2, 3, 4….n
2) Find an i such that both a) Finish[i] = false
b) Needi<= Work
if no such i exists goto step (4)
3) Work = Work + Allocation[i]
Finish[i] = true
goto step (2)
4) if Finish [i] = true for all i then the system is in a safe state
Resource-Request Algorithm
Let Requesti be the request array for process Pi. Requesti [j] = k means process Pi wants k instances of
resource type Rj. When a request for resources is made by process Pi, the following actions are taken:
1) If Requesti<= Needi
Goto step (2) ; otherwise, raise an error condition, since the process has exceeded its maximum claim. 2)
If Requesti<= Available
Goto step (3); otherwise, Pi must wait, since the resources are not available.
3) Have the system pretend to have allocated the requested resources to process Pi by modifying the state as
follows:
Available = Available – Requesti
Allocationi = Allocationi + Requesti
Needi = Needi– Requesti

Downloaded by Arman Ali (a75215710@gmail.com)

 lOMoAR cPSD| 30415125

Example program for Implementation of Banker‟s algorithm

#include <stdio.h> Int
main() { intn,
m, i, j, k; n = 5;
m = 3;
intalloc[5][3] = { { 0, 1, 0 }, { 2, 0, 0 }, { 3, 0, 2 }, { 2, 1, 1 }, { 0, 0, 2 } };
intmax[5][3] = { { 7, 5, 3 }, { 3, 2, 2 }, { 9, 0, 2 }, { 2, 2, 2 }, { 4, 3, 3 } };
intavail[3] = { 3, 3, 2 }; intf[n], ans[n], ind = 0; for(k = 0; k < n;
k++) f[k] = 0; intneed[n][m]; for(i = 0; i < n; i++) {
for(j = 0; j < m; j++) need[i][j] =
max[i][j] - alloc[i][j];
} inty = 0; for(k = 0; k < 5; k++) {
for(i = 0; i < n; i++) {
if(f[i] == 0) { int flag = 0;
for(j = 0; j < m; j++) {
if(need[i][j] > avail[j]){
flag = 1;
break;
}}
if(flag == 0) { ans[ind++] = i;
for(y = 0; y < m; y++)
avail[y] += alloc[i][y];
f[i] = 1;
} } } }
printf("Following is the SAFE Sequence\n");
for(i = 0; i < n - 1; i++)
printf(" P%d ->", ans[i]);
printf(" P%d", ans[n - 1]);
return0;
}
Input: Program 9:

Output:
Following is the SAFE Sequence
P1 -> P3 -> P4 -> P0 -> P2

Downloaded by Arman Ali (a75215710@gmail.com)

 lOMoAR cPSD| 30415125

EXPERIMENT – 10
Objective - Conversion of resource allocation graph (RAG) to wait for graph (WFG) for each type of
method used for storing graph.
Theory –
Wait-for-Graph (WFG)
A Wait-For Graph (WFG) is the same as the SRAG with the resource elements stripped out. Example:

Figure: Resource Allocation Graph

Figure: Equivalent Wait for graph of above resource allocation graph

10. Example program for Implementation of conversion of resource allocation graph (RAG) to wait
for graph (WFG)
#include<stdio.h>
int main(){
int np, nr, temp, temp1;
printf("enter number of resources:
"); scanf("%d", &nr);
printf("enter number of processs: ");
scanf("%d", &np);
int
rag[nr+np][nr+np]; int i, j;
for(i=0;i<np+nr;i++){
for(j=0; j<np+nr;j++){
rag[i][j]=0;
}
}
for(i=0;i<np;i++){ printf("enter the number of resources
process %d, holding", i);
scanf("%d", &temp);
for(j=0; j<temp;j++){
printf("enter the ressorce number process %d holding: ", j);
scanf("%d", &temp1);
rag[np+temp1][i]=1;
}
printf("enter the number of resources process %d, requesting", i);
scanf("%d", &temp);
for(j=0; j<temp;j++){
printf("enter the ressorce number process %d requesting: ", i);
scanf("%d", &temp1);
rag[i][np+temp1]=1;
}}

Downloaded by Arman Ali (a75215710@gmail.com)

 lOMoAR cPSD| 30415125

for(i=0;i<np+nr;i++) { for(j=0; j<np+nr;j++) {

printf("%d ", rag[i][j]);
}
printf("\n ");
}
int wfg[np][np];
for(i=0;i<np;i++){
for(j=0; j<np;j++){
wfg[i][j]=0;
}
}
int k;
for(i=0;i<np;i++){
for(j=np;j<np + nr; j++){
if(rag[i][j] == 1){
for(k=0;k<np;k++){
if(rag[j][k] == 1)
wfg[i][k] = 1;
}
}
}
} for(i=0;i<np;i++){
for(j=0; j<np;j++){
printf("%d ", wfg[i][j]);
}
printf("\n ");
}
return 0;
}
Input: Program 10:
Resource
Process ID Resource Holding
Requesting
Process 0 R0 R2
Process 1 R1 R0
Process 2 R2 R1
Output:
P0 P1 P2 R0 R1 R2
P0 000001
P1 000100
P2 000010
R0 1 00 0 0 0
R1 010000
R2 001000
WFG P0 P1 P2
P0 00 1
P1 10 0
P2 0 10

Downloaded by Arman Ali (a75215710@gmail.com)