├── Bash_Script
    ├── touch.sh
    ├── alpha.sh
    ├── name.sh
    ├── lab5.sh
    ├── ctof.sh
    ├── odd.sh
    ├── lab2.sh
    ├── lab3.sh
    ├── lab1.sh
    ├── string.sh
    ├── operations.sh
    ├── average.sh
    ├── bash.sh
    ├── fibonacci.sh
    ├── largest.sh
    ├── arop.sh
    └── shapes.sh
├── Micro_Project
    ├── micro
    └── micro.c
├── System_Call
    ├── syscall6.c
    ├── syscall3.c
    ├── syscall1.c
    ├── files.c
    ├── directory.c
    ├── syscall4.c
    ├── cat.c
    ├── syscall2.c
    ├── syscall5.c
    └── copyfile.c
├── README.md
├── Shared_Memory
    ├── fact_print.c
    └── fact_read.c
├── Disk_Scheduling
    ├── fcfs.c
    ├── scan.c
    └── cscan.c
├── Page_Replacement
    ├── lru.c
    ├── fifo.c
    └── lfu.c
├── Message_Passing_Model
    └── PCP.c
├── Scheduling
    ├── Non_Preemptive
    │   ├── sjf.c
    │   ├── fcfs.c
    │   └── priority.c
    └── Preemptive
    │   └── roundrobin.c
├── MEMORY ALLOCATION SCHEMES
    └── memory.c
└── Deadlock_Avoidance
    └── bankers.c


/Bash_Script/touch.sh:
--------------------------------------------------------------------------------
1 | touch file.txt
2 | 


--------------------------------------------------------------------------------
/Bash_Script/alpha.sh:
--------------------------------------------------------------------------------
1 | a=$1
2 | b=$2
3 | c=$3
4 | { echo $a;echo $b;echo $c;} | sort
5 | 


--------------------------------------------------------------------------------
/Bash_Script/name.sh:
--------------------------------------------------------------------------------
1 | echo -n "Enter your name:"
2 | read name
3 | echo "Hello $name"
4 | 


--------------------------------------------------------------------------------
/Bash_Script/lab5.sh:
--------------------------------------------------------------------------------
1 | echo "a:"
2 | read a
3 | ((b=a*9/5))
4 | ((b=b+32))
5 | echo "b:$b"
6 | 


--------------------------------------------------------------------------------
/Bash_Script/ctof.sh:
--------------------------------------------------------------------------------
1 | echo -n "a:"
2 | read a
3 | ((b=a*9/5))
4 | ((b=b+32))
5 | echo "b:$b"
6 | 


--------------------------------------------------------------------------------
/Micro_Project/micro:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/JoelBobyM/S4-OS-LAB-KTU/HEAD/Micro_Project/micro


--------------------------------------------------------------------------------
/Bash_Script/odd.sh:
--------------------------------------------------------------------------------
1 | for((i=0;i<100;i++))
2 | do
3 |   if((i%2!=0))
4 |   then
5 |     echo $i
6 |   fi
7 | done
8 | 


--------------------------------------------------------------------------------
/Bash_Script/lab2.sh:
--------------------------------------------------------------------------------
 1 | a=$1
 2 | b=$2
 3 | while((b!=0))
 4 | do
 5 |   ((t=b))
 6 |   ((b=a%b))
 7 |   ((a=t))
 8 | done
 9 | echo $a
10 |   
11 | 


--------------------------------------------------------------------------------
/Bash_Script/lab3.sh:
--------------------------------------------------------------------------------
 1 | read a
 2 | fact=1
 3 | i=1
 4 | while((i<=a))
 5 | do
 6 |   ((fact=fact*i))
 7 |   ((i=i+1))
 8 | done
 9 | echo $fact
10 |   
11 | 


--------------------------------------------------------------------------------
/Bash_Script/lab1.sh:
--------------------------------------------------------------------------------
 1 | a=$1
 2 | b=$2
 3 | while((a!=b))
 4 | do
 5 |   if((a>b))
 6 |   then
 7 |    ((a=a-b))
 8 |   else
 9 |    ((b=b-a))
10 |   fi
11 | done
12 | echo $a
13 | 


--------------------------------------------------------------------------------
/System_Call/syscall6.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<unistd.h>
 3 | void main()
 4 | {
 5 |   fork();
 6 |   fork();
 7 |   fork();
 8 |   fork();
 9 |   printf("Hello World\n");
10 | }
11 |   
12 | 


--------------------------------------------------------------------------------
/Bash_Script/string.sh:
--------------------------------------------------------------------------------
1 | echo -n "Enter first string:"
2 | read s1
3 | echo -n "Enter second string:"
4 | read s2
5 | echo -n "Enter third string:"
6 | read s3
7 | { echo $s1;echo $s2;echo $s3;} | sort
8 | 
9 | 


--------------------------------------------------------------------------------
/System_Call/syscall3.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<unistd.h>
 3 | #include<sys/stat.h>
 4 | void main()
 5 | {
 6 |   struct stat buf;
 7 |   stat("./hello.c",&buf);
 8 |   printf("%d\n",buf.st_mode);
 9 | }
10 | 
11 | 


--------------------------------------------------------------------------------
/Bash_Script/operations.sh:
--------------------------------------------------------------------------------
 1 | a=$1
 2 | b=$2
 3 | ((sum=a+b))
 4 | echo "Sum= $sum"
 5 | ((diff=a-b))
 6 | echo "Difference= $diff"
 7 | ((prod=a*b))
 8 | echo "Product= $prod"
 9 | ((div=a/b))
10 | echo "Quotient= $div"
11 | 
12 | 


--------------------------------------------------------------------------------
/Bash_Script/average.sh:
--------------------------------------------------------------------------------
 1 | echo -n "Enter no:of integers:"
 2 | read n
 3 | sum=0
 4 | for((i=1;i<=n;i++))
 5 | do
 6 |   echo -n "Enter number $i:"
 7 |   read num
 8 |   ((sum=sum+num))
 9 | done
10 | ((avg=sum/n))
11 | echo "Average=$avg"
12 | 


--------------------------------------------------------------------------------
/Bash_Script/bash.sh:
--------------------------------------------------------------------------------
 1 | dir="bash"
 2 | if [ -d $dir ]
 3 | then 
 4 |   echo "directory exists"
 5 | else
 6 |   echo "directory doesnot exist"
 7 |   echo "creating directory..."
 8 |   mkdir $dir
 9 |   echo "directory created"
10 | fi
11 | ls
12 | 
13 | 


--------------------------------------------------------------------------------
/System_Call/syscall1.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<unistd.h>
 3 | void main()
 4 | {
 5 |   pid_t p;
 6 |   p=fork();
 7 |   if(p==0)
 8 |   {
 9 |     printf("I am child\n");
10 |   }
11 |   else if(p>0)
12 |   {
13 |     printf("I am parent\n");
14 |   }
15 | }
16 | 


--------------------------------------------------------------------------------
/Bash_Script/fibonacci.sh:
--------------------------------------------------------------------------------
 1 | echo -n "enter a number:"
 2 | read n
 3 | 
 4 | a=0
 5 | b=1
 6 | ((c=a+b))
 7 | ((n=n-2))
 8 | echo "series:"
 9 | echo $a
10 | echo $b
11 | for((i=1;i<=n;i++))
12 | do
13 |     echo $c
14 |     ((a=b))
15 |     ((b=c))
16 |     ((c=a+b))
17 | done
18 | 


--------------------------------------------------------------------------------
/System_Call/files.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<unistd.h>
 3 | #include<dirent.h>
 4 | void main()
 5 | {
 6 |   DIR *d;
 7 |   struct dirent *de;
 8 |   d=opendir(".");
 9 |   while(de=readdir(d))
10 |   {
11 |     if(de->d_type == DT_REG)
12 |     {
13 |       printf("%s\n",de->d_name);
14 |     }
15 |   }
16 | }
17 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # S4-OS-LAB-KTU
2 | A repository to store efficient Operating System Lab Programs (2019 Scheme KTU)
3 | * Find most of the OS LAB programs through this repository.
4 | * If you have ability then make the already existing codes simpler and efficient
5 | * You're also free to add new programs
6 | 
7 | ### BEST WISHES
8 | 


--------------------------------------------------------------------------------
/System_Call/directory.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<unistd.h>
 3 | #include<dirent.h>
 4 | void main()
 5 | {
 6 |   DIR *d;
 7 |   struct dirent *de;
 8 |   d=opendir(".");
 9 |   while(de=readdir(d))
10 |   {
11 |     if(de->d_type == DT_DIR )
12 |     {
13 |       printf("%s\n",de->d_name);
14 |     }
15 |   }
16 | }
17 | 
18 | 


--------------------------------------------------------------------------------
/System_Call/syscall4.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<unistd.h>
 3 | #include<dirent.h>
 4 | #include<sys/types.h>
 5 | void main()
 6 | {
 7 |   DIR *d;
 8 |   d=opendir("fisat");
 9 |   if(d==NULL)
10 |   {
11 |     printf("Directory doesnot exist\n");
12 |   }
13 |   else
14 |   {
15 |     printf("Directory exist\n");
16 |   }
17 | }
18 | 


--------------------------------------------------------------------------------
/Micro_Project/micro.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<sys/types.h>
 3 | #include<signal.h>
 4 | void main()
 5 | {
 6 |   pid_t pid;
 7 |   printf("ENTER THE PID OF PROCESS TO BE KILLED : ");
 8 |   scanf("%d",&pid);
 9 |   int a = kill(pid, SIGKILL);
10 |   if(a==0)
11 |     printf("PROCESS SUCESSFULLY KILLED\n");
12 |   else
13 |     printf("ERROR WHILE KILL OPERATION : %d\n",a);
14 | }
15 | 


--------------------------------------------------------------------------------
/Bash_Script/largest.sh:
--------------------------------------------------------------------------------
 1 | echo -n "enter number 1:"
 2 | read n1
 3 | echo -n "enter number 2:"
 4 | read n2
 5 | echo -n "enter number 3:"
 6 | read n3
 7 | if ((n1>n2)) && ((n1>n3))
 8 | then
 9 |   echo $n1 "is the largest number"
10 | elif ((n1<n2)) && ((n2>n3))
11 | then
12 |   echo $n2 "is the largest number"
13 | elif ((n3>n1)) && ((n3>n2))
14 | then
15 |   echo $n3 "is the largest number"
16 | fi
17 | 


--------------------------------------------------------------------------------
/System_Call/cat.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<unistd.h>
 3 | #include<sys/wait.h>
 4 | void main(int argc, char *argv[])
 5 | {
 6 |   if(argc != 2)
 7 |   {
 8 |   printf("Argument Error.\n");
 9 |   return;
10 |   }
11 |   char *file= argv[1];
12 |   pid_t p=fork();
13 |   int status;
14 |   if(p==0)
15 |   {
16 |     execl("/usr/bin/cat","cat",file,NULL);
17 |   }
18 |   else
19 |   {
20 |     wait(&status);
21 |   }
22 | }
23 | 
24 | 


--------------------------------------------------------------------------------
/Bash_Script/arop.sh:
--------------------------------------------------------------------------------
 1 |  echo -n "enter first number:"
 2 | read a
 3 | echo -n "enter second number:"
 4 | read b
 5 | echo -n "enter operator:"
 6 | read op
 7 | if [[ $op == "+" ]]
 8 |  then
 9 |    ((c=a+b))
10 | elif [[ $op == "-" ]]
11 | then
12 |     ((c=a-b))
13 | elif [[ $op == "*" ]]
14 | then
15 |     ((c=a*b))
16 | elif [[ $op == "/" ]]
17 | then
18 |     ((c=a/b))
19 | elif [[ $op == "%" ]]
20 | then
21 |     ((c=a%b))
22 | fi
23 | echo "result=$c"
24 | 


--------------------------------------------------------------------------------
/System_Call/syscall2.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<unistd.h>
 3 | void main()
 4 | {
 5 |   pid_t p;
 6 |   int i;
 7 |   p=fork();
 8 |   if(p==0)
 9 |   {
10 |     printf("In child process:\n");
11 |     for(i=1;i<=10;i++)
12 |     {
13 |       printf("%d ",i);
14 |     }
15 |     printf("\n");
16 |   }
17 |   else if(p>0)
18 |   {
19 |     printf("In parent process:\n");
20 |     for(i=1;i<=10;i++)
21 |     {
22 |       printf("%d ",i);
23 |     }
24 |     printf("\n");
25 |   }
26 | }
27 | 


--------------------------------------------------------------------------------
/System_Call/syscall5.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<unistd.h>
 3 | void main()
 4 | {
 5 |   pid_t p;
 6 |   p=fork();
 7 |   if(p==0)
 8 |   {
 9 |     printf("In child process:\n");
10 |     printf("PID of parent process:%d",getppid());
11 |     printf("\nPID of process:%d",getpid());
12 |   }
13 |   else if(p>0)
14 |   {
15 |     printf("In parent process:\n");
16 |     printf("PID of parent process:%d",getppid());
17 |     printf("\nPID of process:%d",getpid());
18 |   }
19 |   printf("\n");
20 | }
21 | 


--------------------------------------------------------------------------------
/Shared_Memory/fact_print.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <fcntl.h>
 3 | #include <stddef.h>
 4 | #include <unistd.h>
 5 | #include <sys/stat.h>
 6 | #include <sys/mman.h>
 7 | void main()
 8 | {
 9 |   int i,fact;
10 |   int fd = shm_open("/os_lab",O_RDONLY,0666);
11 |   int *data = (int *)mmap(NULL,sizeof(int),PROT_READ,MAP_SHARED,fd,0);
12 |   int a = data[0];
13 |   for(i=1,fact=1;i<=a;fact*=i,i++);
14 |   printf("FACTORIAL OF %d IS : %d\n",a,fact);
15 |   munmap(data,sizeof(int));
16 |   close(fd);
17 |   shm_unlink("/os_lab");
18 | }
19 | 


--------------------------------------------------------------------------------
/Shared_Memory/fact_read.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <fcntl.h>
 3 | #include <stddef.h>
 4 | #include <unistd.h>
 5 | #include <sys/stat.h>
 6 | #include <sys/mman.h>
 7 | void main()
 8 | {
 9 |   int fd = shm_open("/os_lab",O_CREAT|O_RDWR,0666);
10 |   int ft = ftruncate(fd,sizeof(int));
11 |   if (ft==-1)
12 |   {
13 |     printf("ERROR!!!\n");
14 |   }
15 |   else
16 |   {
17 |     printf("SHARED MEMORY CREATED\n");
18 |     int *data = (int *)mmap(NULL,sizeof(int),PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
19 |     printf("ENTER THE NUMBER : ");
20 |     scanf("%d",&data[0]);
21 |     munmap(data,sizeof(int));
22 |   }
23 |   close(fd);
24 | }
25 | 


--------------------------------------------------------------------------------
/Disk_Scheduling/fcfs.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 | void main()
 4 | {
 5 | 	int tr[20],cr,n,i,sum=0,new;
 6 | 	printf("ENTER THE NUMBER OF TRACKS : ");
 7 | 	scanf("%d",&n);
 8 | 	printf("ENTER THE HEAD POINTER POSITION : ");
 9 | 	scanf("%d",&cr);
10 | 	printf("ENTER THE TRACKS TO BE TRAVERSED : ");
11 | 	for(i=0;i<n;i++)
12 | 	{
13 | 		new = 0;
14 | 		scanf("%d",&tr[i]);
15 | 		new=cr-tr[i];
16 | 		if(new<0)
17 | 		{
18 | 			new=tr[i]-cr;
19 | 		}
20 | 		cr=tr[i];
21 | 		sum=sum + new;
22 | 	}
23 | 	printf("TRAVERSED ORDER : ");
24 | 	for(i=0;i<n;i++)
25 | 		printf("%d => ",tr[i]);
26 |  	printf("\b\b\b.   \nTOTAL HEAD MOVEMENTS : %d\n",sum);
27 | }
28 | 


--------------------------------------------------------------------------------
/Bash_Script/shapes.sh:
--------------------------------------------------------------------------------
 1 | echo "1.Area of circle"
 2 | echo "2.Circumference of circle"
 3 | echo "3.Area of reactangle"
 4 | echo "4.Area of square"
 5 | echo -n "Enter choice:"
 6 | read ch
 7 | 
 8 | if((ch==1))
 9 | then
10 |   echo -n "Enter Radius:"
11 |   read r
12 |   ((a=((22/7))*r*r))
13 |   echo "Area=$a"
14 | elif((ch==2))
15 | then
16 |   echo -n "Enter Radius:"
17 |   read r
18 |   ((a=2*22/7*r))
19 |   echo "Circumference=$a"
20 | elif((ch==3))
21 | then
22 |   echo -n "Enter length:"
23 |   read l
24 |   echo -n "Enter breadth:"
25 |   read b
26 |   ((a=l*b))
27 |   echo "Area of rectangle=$a"
28 | elif((ch==4))
29 | then
30 |   echo -n "Enter side:"
31 |   read s
32 |   ((a=s*s))
33 |   echo "Area of square=$a"
34 | else
35 |   echo "Invalid Choice"
36 | fi
37 | 


--------------------------------------------------------------------------------
/System_Call/copyfile.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <stdlib.h>
 3 | #include <unistd.h>
 4 | #include <sys/stat.h>
 5 | #include <fcntl.h>
 6 | #include <string.h>
 7 | void main(int argc, char *argv[])
 8 | {
 9 |   if(argc != 3)
10 |   {
11 |     printf("INVALID NUMBER OF ARGUMENTS.\n");
12 |     exit(0);
13 |   }
14 |   char *file1 = argv[1];
15 |   char *file2 = argv[2];
16 |   char wbuf[100] = "START\n";
17 |   char rbuf[100];
18 |   int fd1 = open(file1,O_RDONLY);
19 |   int fd2 = open(file2,O_CREAT|O_WRONLY,S_IRWXU);
20 |   write(fd2,wbuf,strlen(wbuf));
21 |   read(fd1,rbuf,100);
22 |   write(fd2,rbuf,strlen(rbuf));
23 |   strcpy(wbuf,"STOP");
24 |   write(fd2,wbuf,strlen(wbuf));
25 |   printf("SUCCESSFULLY COPIED\n");
26 |   close(fd1);
27 |   close(fd2);
28 | }
29 | 


--------------------------------------------------------------------------------
/Page_Replacement/lru.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | struct frames
 3 | {
 4 | 	int content,count;
 5 | }frame[100];
 6 | void main()
 7 | {
 8 | 	int i,j,k,p,f,page[100],cnt=1,min,pf=0,id=0;
 9 | 	printf("ENTER THE NUMBER OF PAGES : ");
10 | 	scanf("%d",&p);
11 | 	printf("ENTER THE REFERENCING STRING : ");
12 | 	for(i=0;i<p;i++)
13 | 	{
14 | 		scanf("%d",&page[i]);
15 | 	}
16 | 	printf("ENTER THE NUMBER OF FRAMES : ");
17 | 	scanf("%d",&f);
18 | 	for(i=0;i<f;i++)
19 | 	{
20 | 		frame[i].content = -1;
21 | 		frame[i].count = 0;
22 | 	}
23 | 	printf("\nREFERENCING PAGE\tSTATUS\t\tFRAME CONTENT\n\n");
24 | 	for(i=0;i<p;i++)
25 | 	{
26 | 		printf("\t%d\t\t",page[i]);
27 | 		for(j=0;j<f;j++)
28 | 		{
29 | 			if(frame[j].content == page[i])
30 | 			{
31 | 				printf("HIT\t\t");
32 | 				frame[j].count = cnt++;
33 | 				break;
34 | 			}
35 | 		}
36 | 		if(j==f)
37 | 		{
38 | 			printf("MISS\t\t");
39 | 			if(id<f)
40 | 			{
41 | 				frame[id].content = page[i];
42 | 				frame[id].count = cnt++;
43 | 				id++;
44 | 			}
45 | 			else
46 | 			{
47 | 				min=0;
48 | 				for(k=0;k<f;k++)
49 | 				{
50 | 					if(frame[k].count<frame[min].count)
51 | 						min = k;
52 | 				}
53 | 				frame[min].content = page[i];
54 | 				frame[min].count = cnt++;
55 | 			}
56 | 			pf++;
57 | 		}
58 | 		for(j=0;j<f;j++)
59 | 		{
60 | 			if(frame[j].content !=-1)
61 | 				printf("%d\t",frame[j].cnt);
62 | 		}
63 | 		printf("\n");
64 | 	}
65 | 	printf("\nPAGE FAULT : %d\n",pf);
66 | }
67 | 


--------------------------------------------------------------------------------
/Disk_Scheduling/scan.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int n,m,i,j,h,p,temp,k,total=0;
 3 | int t[100],a[100],diff;
 4 | void main()
 5 | {
 6 |   printf("ENTER THE NUMBER OF TRACKS : ");
 7 |   scanf("%d",&n);
 8 |   printf("ENTER THE HEAD POINTER POSITION : ");
 9 |   scanf("%d",&h);
10 |   printf("ENTER THE TRACKS TO BE TRAVERSED : ");
11 |   for(i=0;i<n;i++)
12 |   {
13 |     scanf("%d",&t[i]);
14 |   }
15 |   t[n+2] = 199;
16 |   t[n+1] = 0;
17 |   t[n] = h;
18 |   n=n+3;
19 |   for(i=0;i<n;i++)
20 |   {
21 |     for(j=0;j<n-i-1;j++)
22 |     {
23 |       if(t[j]>t[j+1])
24 |       {
25 |         temp=t[j];
26 |         t[j]=t[j+1];
27 |         t[j+1]=temp;
28 |       }
29 |     }
30 |   }
31 |   for(i=0;i<n;i++)
32 |   {
33 |     if(t[i]==h)
34 |     {
35 |       k=i;
36 |       break;
37 |     }
38 |   }
39 |   if(h<(199-h))
40 |   {
41 |     for(i=k;i>=0;i--,p++)
42 |     {
43 |       a[p]=t[i];
44 |     }
45 |     for(i=k+1;i<n-1;i++,p++)
46 |     {
47 |       a[p]=t[i];
48 |     }
49 |   }
50 |   else
51 |   {
52 |     for(i=k;i<n;i++,p++)
53 |     {
54 |       a[p]=t[i];
55 |     }
56 |     for(i=k-1;i>=0;i--,p++)
57 |     {
58 |       a[p]=t[i];
59 |     }
60 |   }
61 |   printf("TRAVERSED ORDER : ");
62 |   for(i=0;i<p;i++)
63 |   {
64 |     printf("%d => ",a[i]);
65 |   }
66 |   for(total=0,j=0;j<p-1;j++)
67 |   {
68 |     diff=0;
69 |     if(a[j]>a[j+1])
70 |     {
71 |       diff=a[j]-a[j+1];
72 |     }
73 |     else
74 |     {
75 |       diff=a[j+1]-a[j];
76 |     }
77 |     total=total+diff;
78 |   }
79 |   printf("\b\b\b.  \nTOTAL HEAD MOVEMENTS : %d\n",total);
80 | }
81 | 


--------------------------------------------------------------------------------
/Disk_Scheduling/cscan.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | int n,m,i,j,h,p,temp,k,total=0;
 3 | int t[100],a[100],diff[100];
 4 | void main()
 5 | {
 6 |   printf("ENTER THE NUMBER OF TRACKS : ");
 7 |   scanf("%d",&n);
 8 |   printf("ENTER THE HEAD POINTER POSITION : ");
 9 |   scanf("%d",&h);
10 |   printf("ENTER THE TRACKS TO BE TRAVERSED : ");
11 |   for(i=0;i<n;i++)
12 |   {
13 |     scanf("%d",&t[i]);
14 |   }
15 |   t[n+2] = 199;
16 |   t[n+1] = 0;
17 |   t[n] = h;
18 |   n=n+3;
19 |   for(i=0;i<n;i++)
20 |   {
21 |     for(j=0;j<n-i-1;j++)
22 |     {
23 |       if(t[j]>t[j+1])
24 |       {
25 |         temp=t[j];
26 |         t[j]=t[j+1];
27 |         t[j+1]=temp;
28 |       }
29 |     }
30 |   }
31 |   for(i=0;i<n;i++)
32 |   {
33 |     if(t[i]==h)
34 |     {
35 |       k=i;
36 |       break;
37 |     }
38 |   }
39 |   if(h<(199-h))
40 |   {
41 |     for(i=k;i>=0;i--,p++)
42 |     {
43 |       a[p]=t[i];
44 |     }
45 |     for(i=n-1;i>k;i--,p++)
46 |     {
47 |       a[p]=t[i];
48 |     }
49 |   }
50 |   else
51 |   {
52 |     for(i=k;i<n;i++,p++)
53 |     {
54 |       a[p]=t[i];
55 |     }
56 |     for(i=0;i<k;i++,p++)
57 |     {
58 |       a[p]=t[i];
59 |     }
60 |   }
61 |   printf("TRAVERSED ORDER : ");
62 |   for(i=0;i<p;i++)
63 |   {
64 |     printf("%d => ",a[i]);
65 |   }
66 |   for(total=0,j=0;j<p-1;j++)
67 |   {
68 |     int diff=0;
69 |     if(a[j]>a[j+1])
70 |     {
71 |       diff=a[j]-a[j+1];
72 |     }
73 |     else
74 |     {
75 |       diff=a[j+1]-a[j];
76 |     }
77 |     total=total+diff;
78 |   }
79 |   printf("\b\b\b.  \nTOTAL HEAD MOVEMENTS : %d\n",total);
80 | }
81 | 


--------------------------------------------------------------------------------
/Page_Replacement/fifo.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | void main()
 3 | {
 4 | 	int i,j,n,m,fnd,pg[100],fr[100],k=0,cnt=0;
 5 | 	printf("ENTER THE NUMBER OF PAGES : ");
 6 | 	scanf("%d",&n);
 7 | 	for(i=0;i<n;i++)
 8 | 	{
 9 | 		printf("ENTER THE PAGE NUMBER %d: ",i+1);
10 | 		scanf("%d",&pg[i]);
11 | 	}
12 | 	printf("ENTER THE NUMBER OF FRAMES : ");
13 | 	scanf("%d",&m);
14 | 	for(i=0;i<m;i++)
15 | 	{
16 | 		fr[i]=-1;
17 | 	}
18 | 	printf("\n\tREFERENCE STRING\t PAGE NUMBER\t\t  STATUS\n");
19 | 	for(i=0;i<n;i++)
20 | 	{
21 | 		fnd=0;
22 | 		printf("\t\t%d\t\t",pg[i]);
23 | 		for(j=0;j<m;j++)
24 | 		{
25 | 			if(fr[j]==pg[i])
26 | 			{
27 | 				fnd = 1;
28 | 			}
29 | 		}
30 | 		if(fnd == 0)
31 | 		{
32 | 			fr[k] = pg[i];
33 | 			k = (k+1)%m;
34 | 			cnt++;
35 | 		}
36 | 		for(j=0;j<m;j++)
37 | 		{
38 | 			if(fr[j] != -1)
39 | 			{
40 | 				printf("%d   ",fr[j]);
41 | 			}
42 | 		}
43 | 		if(fnd==1)
44 | 		{
45 | 			printf("\t\tHIT\n");
46 | 		}
47 | 		else
48 | 		{
49 | 			printf("\t\tMISS\n");
50 | 		}
51 | 	}
52 | 	printf("\nPAGE FAULT : %d\n",cnt);
53 | }
54 | 
55 | 
56 | 
57 | 
58 | /* OUTPUT
59 | 
60 | ENTER THE NUMBER OF PAGES : 5
61 | ENTER THE PAGE NUMBER 1: 1
62 | ENTER THE PAGE NUMBER 2: 2
63 | ENTER THE PAGE NUMBER 3: 3
64 | ENTER THE PAGE NUMBER 4: 2
65 | ENTER THE PAGE NUMBER 5: 5
66 | ENTER THE NUMBER OF FRAMES : 3
67 | 
68 | 	REFERENCE STRING	 PAGE NUMBER		  STATUS
69 | 					1						1   		 		 	   MISS
70 | 					2						1   2   				 MISS
71 | 					3						1   2   3   		 MISS
72 | 					2						1   2   3   		 HIT
73 | 					5						5   2   3   		 MISS
74 | 
75 | PAGE FAULT : 4
76 | */
77 | 


--------------------------------------------------------------------------------
/Message_Passing_Model/PCP.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<semaphore.h>
 3 | #include<pthread.h>
 4 | #include<time.h>
 5 | sem_t mutex,full,empty;
 6 | int buffer[5],put=0,get=0,item=1,pro[20],con[20],gitem;
 7 | void *producer(void *arg)
 8 | {
 9 |   do
10 |   {
11 |     sem_wait(&empty);
12 |     sem_wait(&mutex);
13 |     buffer[put%5]=item;
14 | 
15 |     int *myid = (int *)arg;
16 |     printf("PRODUCER %d PRODUCES %d ITEM => BUFFER[%d] : %d\n",*myid,buffer[put%5],put%5,item);
17 |     item++;
18 |     put++;
19 |     sem_post(&mutex);
20 |     sem_post(&full);
21 |     sleep(3);
22 |   }
23 |   while(1);
24 | }
25 | void *consumer(void *arg)
26 | {
27 |   do
28 |   {
29 |     sem_wait(&full);
30 |     sem_wait(&mutex);
31 |     gitem=buffer[get%5];
32 |     int *myid = (int *)arg;
33 |     printf("CONSUMER %d CONSUMES %d ITEM OF BUFFER[%d]\n",*myid,gitem,get%5);
34 |     get++;
35 |     sem_post(&mutex);
36 |     sem_post(&empty);
37 |     sleep(2);
38 |   }
39 |   while(1);
40 | }
41 | void main()
42 | {
43 |   int p,c,j,k;
44 |   pthread_t a[10],b[10];
45 |   sem_init(&mutex,0,1);
46 |   sem_init(&full,0,0);
47 |   sem_init(&empty,0,5);
48 |   printf("ENTER THE NUMBER OF PRODUCERS : ");
49 |   scanf("%d",&p);
50 |   printf("ENTER THE NUMBER OF CONSUMERS : ");
51 |   scanf("%d",&c);
52 |   for(j=0;j<p;j++)
53 |   {
54 |     pro[j]=j+1;
55 |     pthread_create(&a[j],NULL,producer,(void *)&pro[j]);
56 |   }
57 |   for(k=0;k<c;k++)
58 |   {
59 |     con[k]=k+1;
60 |     pthread_create(&b[k],NULL,consumer,(void *)&con[k]);
61 |   }
62 |   for(j=0;j<p;j++)
63 |   {
64 |     pthread_join(&a[j],NULL);
65 |   }
66 |   for(k=0;k<c;k++)
67 |   {
68 |     pthread_join(&b[k],NULL);
69 |   }
70 | }
71 | 


--------------------------------------------------------------------------------
/Page_Replacement/lfu.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | struct frame
 3 | {
 4 |   int content;
 5 |   int freq;
 6 |   int cnt;
 7 | }frames[100];
 8 | void main()
 9 | {
10 |   int i,j,pg,fr,cnt,pf,min,page[100],id=0;
11 |   printf("ENTER THE NUMBER OF PAGES : ");
12 |   scanf("%d",&pg);
13 |   printf("ENTER THE REFERENCING STRING : ");
14 |   for(i=0;i<pg;i++)
15 |   {
16 |     scanf("%d",&page[i]);
17 |   }
18 |   printf("ENTER THE NUMBER OF FRAMES : ");
19 |   scanf("%d",&fr);
20 |   for(i=0;i<fr;i++)
21 |   {
22 |     frames[i].content = -1;
23 |     frames[i].freq = 0;
24 |     frames[i].cnt = 0;
25 |   }
26 |   printf("\nREFERENCING PAGE\tSTATUS\t\tFRAME CONTENT\n\n");
27 |   for(pf=0,cnt=1,i=0;i<pg;i++)
28 |   {
29 |     printf("\t%d\t\t",page[i]);
30 |     for(j=0;j<fr;j++)
31 |     {
32 |       if(frames[j].content == page[i])
33 |       {
34 |         printf("HIT\t\t");
35 |         frames[j].freq++;
36 |         break;
37 |       }
38 |     }
39 |     if(j == fr)
40 |     {
41 |       printf("MISS\t\t");
42 |       if(id<fr)
43 |       {
44 |         frames[id].content = page[i];
45 |         frames[id].freq++;
46 |         frames[id].cnt = cnt++;
47 |         id++;
48 |       }
49 |       else
50 |       {
51 |         for(min=0,j=0;j<fr;j++)
52 |         {
53 |           if(frames[min].freq > frames[j].freq)
54 |           {
55 |             min = j;
56 |           }
57 |           else if(frames[min].freq == frames[j].freq && frames[min].cnt > frames[j].cnt)
58 |           {
59 |             min = j;
60 |           }
61 |         }
62 |         frames[min].content = page[i];
63 |         frames[min].freq = 1;
64 |         frames[min].cnt = cnt++;
65 |       }
66 |       pf++;
67 |     }
68 |     for(j=0;j<fr;j++)
69 |     {
70 |       if(frames[j].content !=-1)
71 |         printf("%d\t",frames[j].content);
72 |     }
73 |     printf("\n");
74 |   }
75 |   printf("\nTOTAL PAGE FAULT : %d\n",pf);
76 | }
77 | 


--------------------------------------------------------------------------------
/Scheduling/Non_Preemptive/sjf.c:
--------------------------------------------------------------------------------
  1 | #include<stdio.h>
  2 | #include<string.h>
  3 | struct process
  4 | {
  5 |   char name[20];
  6 |   int at,tt,bt,wt,status,ct;
  7 | }p[20],temp;
  8 | struct done
  9 | {
 10 |   char name[20];
 11 |   int st,ct;
 12 | }d[20];
 13 | void main()
 14 | {
 15 |   int n,i,j,ls,min,fnd,num,idle;
 16 |   float twt=0.0,ttt=0.0;
 17 |   printf("ENTER THE NUMBER OF PROCESSES : ");
 18 |   scanf("%d",&n);
 19 |   for(i=0;i<n;i++)                         //Input process details
 20 |   {
 21 |     printf("\nENTER DETAILS OF PROCESS %d",i+1);
 22 |     printf("\nPROCESS NAME : ");
 23 |     scanf(" %s",p[i].name);
 24 |     printf("ARRIVAL TIME : ");
 25 |     scanf("%d",&p[i].at);
 26 |     printf("BURST TIME : ");
 27 |     scanf("%d",&p[i].bt);
 28 |     p[i].status = 0;
 29 |   }
 30 |   for(i=0,ls=0,num=0,idle=0;ls<n;)
 31 |   {
 32 |     for(j=0,fnd=0;j<n;j++)
 33 |     {
 34 |       if(i>=p[j].at && p[j].status==0)
 35 |       {
 36 |         if(fnd==0)
 37 |         {
 38 |           min = j;
 39 |           fnd = 1;
 40 |         }
 41 |         else if(fnd!=0 && p[min].bt>p[j].bt)
 42 |         {
 43 |           min = j;
 44 |         }
 45 |       }
 46 |     }
 47 |     if(idle==0 && fnd==0)
 48 |     {
 49 |       strcpy(d[num].name,"Idle");
 50 |       d[num].st = i;
 51 |       i++;
 52 |       idle = 1;
 53 |     }
 54 |     else if(fnd==1)
 55 |     {
 56 |       if(idle==1)
 57 |       {
 58 |         d[num].ct = i;
 59 |         num++;
 60 |         idle = 0;
 61 |       }
 62 |       strcpy(d[num].name,p[min].name);
 63 |       p[min].status =1;
 64 |       d[num].st = i;
 65 |       d[num].ct = i + p[min].bt;
 66 |       i = d[num].ct;
 67 |       p[min].ct = d[num].ct;
 68 |       p[min].tt = p[min].ct - p[min].at;
 69 |       p[min].wt = p[min].tt - p[min].bt;
 70 |       num++;
 71 |       ls++;
 72 |     }
 73 |     else
 74 |     {
 75 |       i++;
 76 |     }
 77 |   }
 78 |   printf("\nPROCESS NAME\tCOMPLETION TIME (ms)\tWAITING TIME (ms)\tTURNAROUND TIME (ms)\n\n");
 79 |   for(i=0;i<n;i++)
 80 |   {
 81 |     printf("    %s\t\t\t%d\t\t\t%d\t\t\t%d\n",p[i].name,p[i].ct,p[i].wt,p[i].tt);
 82 |     twt+=p[i].wt;
 83 |     ttt+=p[i].tt;
 84 |   }
 85 |   printf("\n\nGANTT CHART ");
 86 |   printf("\n\t--------------------------------------------------------------------\n\t");
 87 |   for(i=0;i<num;i++)
 88 |   {
 89 |     printf("|");
 90 |     printf("%s\t",d[i].name);
 91 |   }
 92 |   printf(" |");
 93 |   printf("\n\t--------------------------------------------------------------------\n\t");
 94 |   for(i=0;i<num;i++)
 95 |   {
 96 |       printf("%d\t",d[i].st);
 97 |   }
 98 |   printf("%d\t\n",d[num-1].ct);
 99 |   printf("\nAVERAGE WAITING TIME : %f",(twt/n));
100 |   printf("\nAVERAGE TURNAROUND TIME : %f\n",(ttt/n));
101 | }
102 | 


--------------------------------------------------------------------------------
/Scheduling/Non_Preemptive/fcfs.c:
--------------------------------------------------------------------------------
  1 | #include<stdio.h>
  2 | #include<string.h>
  3 | struct process
  4 | {
  5 |   char name[20];
  6 |   int at,tt,bt,wt,ct,status;
  7 | }p[20],temp;
  8 | struct done
  9 | {
 10 |   char name[20];
 11 |   int st,ct;
 12 | }d[20];
 13 | void main()
 14 | {
 15 |   int i,j,n,num,idle=0;
 16 |   float avwt=0;
 17 |   float avtt=0;
 18 |   printf("ENTER THE NUMBER OF PROCESSES : ");
 19 |   scanf("%d",&n);
 20 |   for(i=0;i<n;i++)                         //Input process details
 21 |   {
 22 |     printf("\nENTER DETAILS OF PROCESS %d",i+1);
 23 |     printf("\nPROCESS NAME : ");
 24 |     scanf(" %s",p[i].name);
 25 |     printf("ARRIVAL TIME : ");
 26 |     scanf("%d",&p[i].at);
 27 |     printf("BURST TIME : ");
 28 |     scanf("%d",&p[i].bt);
 29 |     p[i].status = 0;
 30 |   }
 31 |   for(i=0;i<n;i++)                       //Sorting based on at
 32 |   {
 33 |     for(j=0;j<n-i-1;j++)
 34 |     {
 35 |       if(p[j].at > p[j+1].at)
 36 |       {
 37 |         temp = p[j];
 38 |         p[j] = p[j+1];
 39 |         p[j+1] = temp;
 40 |       }
 41 |     }
 42 |   }
 43 |   for(i=0,j=0,num=0;j<n;)              //Calculations
 44 |   {
 45 |     if(p[j].at<=i && p[j].status==0)
 46 |     {
 47 |       if(idle==1)
 48 |       {
 49 |         d[num].ct=i;
 50 |         num++;
 51 |         idle = 0;
 52 |       }
 53 |       strcpy(d[num].name,p[j].name);
 54 |       d[num].st = i;
 55 |       d[num].ct = i + p[j].bt;
 56 |       p[j].wt = d[num].st - p[j].at;
 57 |       p[j].tt = p[j].wt + p[j].bt;
 58 |       p[j].ct = d[num].ct;
 59 |       i = d[num].ct;
 60 |       p[j].status = 1;
 61 |       j++;
 62 |       num++;
 63 | 
 64 |     }
 65 |     else if(idle == 0)
 66 |     {
 67 |       strcpy(d[num].name,"Idle");
 68 |       d[num].st = i;
 69 |       i++;
 70 |       idle = 1;
 71 |     }
 72 |     else
 73 |     {
 74 |       i++;
 75 |     }
 76 |   }
 77 |   printf("\nPROCESS NAME\tCOMPLETION TIME (ms)\tWAITING TIME (ms)\tTURNAROUND TIME (ms)\n");
 78 |   for(int i=0;i<n;i++)
 79 |   {
 80 |     printf("    %s\t\t\t%d\t\t\t%d\t\t\t%d\n",p[i].name,p[i].ct,p[i].wt,p[i].tt);
 81 |     avwt+=p[i].wt;
 82 |     avtt+=p[i].tt;
 83 |   }
 84 |   printf("\n\nGANTT CHART ");
 85 |   printf("\n----------------------------------------------------------\n");
 86 |       for(i=0;i<num;i++)
 87 |       {
 88 |           printf("|");
 89 |           printf("   %s\t",d[i].name);
 90 |        }
 91 |        printf(" |");
 92 |        printf("\n----------------------------------------------------------\n");
 93 |        for(i=0;i<num;i++)
 94 |        {
 95 |           printf("%d\t",d[i].st);
 96 |        }
 97 |        printf("%d\t",d[num-1].ct);
 98 |   printf("\n\nAVERAGE WAITING TIME : %f",(avwt/n));
 99 |   printf("\nAVERAGE TURNAROUND TIME : %f\n",(avtt/n));
100 | }
101 | 


--------------------------------------------------------------------------------
/Scheduling/Non_Preemptive/priority.c:
--------------------------------------------------------------------------------
  1 | #include<stdio.h>
  2 | #include<string.h>
  3 | struct process
  4 | {
  5 |   char name[20];
  6 |   int at,tt,bt,wt,status,ct,pr;
  7 | }p[20],temp;
  8 | struct done
  9 | {
 10 |   char name[20];
 11 |   int st,ct;
 12 | }d[20];
 13 | void main()
 14 | {
 15 |   int n,i,j,ls,min,fnd,num,idle;
 16 |   float twt=0.0,ttt=0.0;
 17 |   printf("ENTER THE NUMBER OF PROCESSES : ");
 18 |   scanf("%d",&n);
 19 |   for(i=0;i<n;i++)                         //Input process details
 20 |   {
 21 |     printf("\nENTER DETAILS OF PROCESS %d",i+1);
 22 |     printf("\nPROCESS NAME : ");
 23 |     scanf(" %s",p[i].name);
 24 |     printf("ARRIVAL TIME : ");
 25 |     scanf("%d",&p[i].at);
 26 |     printf("BURST TIME : ");
 27 |     scanf("%d",&p[i].bt);
 28 |     printf("PRIORITY : ");
 29 |     scanf("%d",&p[i].pr);
 30 |     p[i].status = 0;
 31 |   }
 32 |   for(i=0,ls=0,num=0,idle=0;ls<n;)
 33 |   {
 34 |     for(j=0,fnd=0;j<n;j++)
 35 |     {
 36 |       if(i>=p[j].at && p[j].status==0)
 37 |       {
 38 |         if(fnd==0)
 39 |         {
 40 |           min = j;
 41 |           fnd = 1;
 42 |         }
 43 |         else if((p[min].pr>p[j].pr)||(p[min].pr==p[j].pr && p[min].at>p[j].at))
 44 |         {
 45 |           min = j;
 46 |         }
 47 |       }
 48 |     }
 49 |     if(idle==0 && fnd==0)
 50 |     {
 51 |       strcpy(d[num].name,"Idle");
 52 |       d[num].st = i;
 53 |       i++;
 54 |       idle = 1;
 55 |     }
 56 |     else if(fnd==1)
 57 |     {
 58 |       if(idle==1)
 59 |       {
 60 |         d[num].ct = i;
 61 |         num++;
 62 |         idle = 0;
 63 |       }
 64 |       strcpy(d[num].name,p[min].name);
 65 |       p[min].status =1;
 66 |       d[num].st = i;
 67 |       d[num].ct = i + p[min].bt;
 68 |       i = d[num].ct;
 69 |       p[min].ct = d[num].ct;
 70 |       p[min].tt = p[min].ct - p[min].at;
 71 |       p[min].wt = p[min].tt - p[min].bt;
 72 |       num++;
 73 |       ls++;
 74 |     }
 75 |     else
 76 |     {
 77 |       i++;
 78 |     }
 79 |   }
 80 |   printf("\nPROCESS NAME\tCOMPLETION TIME (ms)\tWAITING TIME (ms)\tTURNAROUND TIME (ms)\n\n");
 81 |   for(i=0;i<n;i++)
 82 |   {
 83 |     printf("    %s\t\t\t%d\t\t\t%d\t\t\t%d\n",p[i].name,p[i].ct,p[i].wt,p[i].tt);
 84 |     twt+=p[i].wt;
 85 |     ttt+=p[i].tt;
 86 |   }
 87 |   printf("\n\nGANTT CHART ");
 88 |   printf("\n\t--------------------------------------------------------------------\n\t");
 89 |   for(i=0;i<num;i++)
 90 |   {
 91 |     printf("|");
 92 |     printf("%s\t",d[i].name);
 93 |   }
 94 |   printf(" |");
 95 |   printf("\n\t--------------------------------------------------------------------\n\t");
 96 |   for(i=0;i<num;i++)
 97 |   {
 98 |       printf("%d\t",d[i].st);
 99 |   }
100 |   printf("%d\t\n",d[num-1].ct);
101 |   printf("\nAVERAGE WAITING TIME : %f",(twt/n));
102 |   printf("\nAVERAGE TURNAROUND TIME : %f\n",(ttt/n));
103 | }
104 | 


--------------------------------------------------------------------------------
/MEMORY ALLOCATION SCHEMES/memory.c:
--------------------------------------------------------------------------------
  1 | #include<stdio.h>
  2 | void firstfit(int p_size[],int n,int m_size[],int m)
  3 | {
  4 |   printf("\t\tFIRST FIT \n");
  5 |   int i,j,flag,psize[100],msize[100];
  6 |   for(i=0;i<n;i++)
  7 |   {
  8 |     psize[i] = p_size[i];
  9 |   }
 10 |   for(i=0;i<m;i++)
 11 |   {
 12 |     msize[i] = m_size[i];
 13 |   }
 14 |   for(i=0;i<n;i++)
 15 |   {
 16 |     flag=0;
 17 |     for(j=0;j<m;j++)
 18 |     {
 19 |       if(msize[j]>=psize[i])
 20 |       {
 21 |         printf("%d ALLOCATED IN %d MEMORY BLOCK",psize[i],msize[j]);
 22 |         msize[j] = msize[j]-psize[i];
 23 |         printf(" => %d SPACE REMAINING \n",msize[j]);
 24 |         flag=1;
 25 |         break;
 26 |       }
 27 |     }
 28 |     if(flag==0)
 29 |     {
 30 |       printf("%d CANNOT BE ALLOCATED \n",psize[i]);
 31 |     }
 32 |   }
 33 | }
 34 | void worstfit(int p_size[],int n,int m_size[],int m)
 35 | {
 36 |   printf("\t\tWORST FIT \n");
 37 |   int i,j,max,loc,psize[100],msize[100];
 38 |   for(i=0;i<n;i++)
 39 |   {
 40 |     psize[i] = p_size[i];
 41 |   }
 42 |   for(i=0;i<m;i++)
 43 |   {
 44 |     msize[i] = m_size[i];
 45 |   }
 46 |   for(i=0;i<n;i++)
 47 |   {
 48 |     max = msize[0];
 49 |     loc = 0;
 50 |     for(j=0;j<m;j++)
 51 |     {
 52 |       if(msize[j]>max)
 53 |       {
 54 |         max = msize[j];
 55 |         loc = j;
 56 |       }
 57 |     }
 58 |     if(max>=psize[i])
 59 |     {
 60 |       printf("%d ALLOCATED IN %d MEMORY BLOCK",psize[i],msize[loc]);
 61 |       msize[loc] = msize[loc]-psize[i];
 62 |       printf(" => %d SPACE REMAINING \n",msize[loc]);
 63 |     }
 64 |     else
 65 |     {
 66 |       printf("%d CANNOT BE ALLOCATED \n",psize[i]);
 67 |     }
 68 |   }
 69 | }
 70 | void bestfit(int p_size[],int n,int m_size[],int m)
 71 | {
 72 |   printf("\t\tBEST FIT \n");
 73 |   int i,j,max,loc,psize[100],msize[100];
 74 |   for(i=0;i<n;i++)
 75 |   {
 76 |     psize[i] = p_size[i];
 77 |   }
 78 |   for(i=0;i<m;i++)
 79 |   {
 80 |     msize[i] = m_size[i];
 81 |   }
 82 |   for(i=0;i<n;i++)
 83 |   {
 84 |     loc = -1;
 85 |     for(j=0;j<m;j++)
 86 |     {
 87 |       if(msize[j]>=psize[i])
 88 |       {
 89 |         if(loc == -1)
 90 |         {
 91 |           loc = j;
 92 |         }
 93 |         else if(msize[loc]>msize[j])
 94 |         {
 95 |           loc = j;
 96 |         }
 97 |       }
 98 |     }
 99 |     if(loc != -1)
100 |     {
101 |       printf("%d ALLOCATED IN %d MEMORY BLOCK",psize[i],msize[loc]);
102 |       msize[loc] = msize[loc]-psize[i];
103 |       printf(" => %d SPACE REMAINING \n",msize[loc]);
104 |     }
105 |     else
106 |     {
107 |       printf("%d CANNOT BE ALLOCATED \n",psize[i]);
108 |     }
109 |   }
110 | }
111 | void main()
112 | {
113 |   int i,p_size[100],m_size[100],n,m;
114 |   printf("ENTER THE NUMBER OF PROCESS : ");
115 |   scanf("%d",&n);
116 |   printf("ENTER THE ARRAY OF PROCESS : ");
117 |   for(i=0;i<n;i++)
118 |   {
119 |     scanf("%d",&p_size[i]);
120 |   }
121 |   printf("ENTER THE NUMBER OF MEMORY BLOCK : ");
122 |   scanf("%d",&m);
123 |   printf("ENTER THE ARRAY OF MEMORY BLOCK : ");
124 |   for(i=0;i<m;i++)
125 |   {
126 |     scanf("%d",&m_size[i]);
127 |   }
128 |   firstfit(p_size,n,m_size,m);
129 |   bestfit(p_size,n,m_size,m);
130 |   worstfit(p_size,n,m_size,m);
131 | }
132 | 


--------------------------------------------------------------------------------
/Scheduling/Preemptive/roundrobin.c:
--------------------------------------------------------------------------------
  1 | #include <stdio.h>
  2 | #include <string.h>
  3 | int q[100],front=-1,rear=-1;
  4 | struct process
  5 | {
  6 |   char name[20];
  7 |   int at,tt,bt,wt,status,left,ct;
  8 | }p[20],temp;
  9 | struct done
 10 | {
 11 |   char name[20];
 12 |   int st,ct;
 13 | }d[20];
 14 | void enqueue(int j)
 15 | {
 16 |   if(front==-1 && rear==-1)
 17 |   {
 18 |     front++;
 19 |   }
 20 |   rear++;
 21 |   q[rear] = j;
 22 | }
 23 | int dequeue()
 24 | {
 25 |   int item;
 26 |   item = q[front];
 27 |   if(front == rear)
 28 |   {
 29 |     front = -1;
 30 |     rear = -1;
 31 |   }
 32 |   else
 33 |   {
 34 |     front++;
 35 |   }
 36 |   return(item);
 37 | }
 38 | void main()
 39 | {
 40 |   int n,i,j,idle=0,k,num,ls,t;
 41 |   float avwt=0,avtt=0;
 42 |   printf("ENTER THE NUMBER OF PROCESSES : ");
 43 |   scanf("%d",&n);
 44 |   for(i=0;i<n;i++)                         //Input process details
 45 |   {
 46 |     printf("\nENTER DETAILS OF PROCESS %d",i+1);
 47 |     printf("\nPROCESS NAME : ");
 48 |     scanf(" %s",p[i].name);
 49 |     printf("ARRIVAL TIME : ");
 50 |     scanf("%d",&p[i].at);
 51 |     printf("BURST TIME : ");
 52 |     scanf("%d",&p[i].bt);
 53 |     p[i].left = p[i].bt;
 54 |     p[i].status = 0;
 55 |   }
 56 |   printf("\nENTER THE TIME QUANTUM : ");
 57 |   scanf("%d",&t);
 58 | 
 59 |   for(i=0,num=0,ls=0;ls<n;)
 60 |   {
 61 |     for(j=0;j<n;j++)
 62 |     {
 63 |       if(p[j].status==0 && p[j].at<=i)
 64 |       {
 65 |         enqueue(j);
 66 |         p[j].status = 1;
 67 |       }
 68 |     }
 69 |     if(idle==0 && front == -1)
 70 |     {
 71 |       strcpy(d[num].name,"Idle");
 72 |       d[num].st = i;
 73 |       idle = 1;
 74 |       i++;
 75 |     }
 76 |     else if(front!=-1)
 77 |     {
 78 |       if(idle==1)
 79 |       {
 80 |         d[num].ct = i;
 81 |         idle = 0;
 82 |         num++;
 83 |       }
 84 |       k = dequeue();
 85 |       d[num].st = i;
 86 |       strcpy(d[num].name,p[k].name);
 87 |       if(p[k].left<=t)
 88 |       {
 89 |         d[num].ct = i+p[k].left;
 90 |         p[k].ct = d[num].ct;
 91 |         i = d[num].ct;
 92 |         p[k].tt = i - p[k].at;
 93 |         p[k].wt = p[k].tt - p[k].bt;
 94 |         p[k].status = 2;
 95 |         ls++;
 96 |         num++;
 97 |       }
 98 |       else if(p[k].left>t)
 99 |       {
100 |         d[num].ct = i+t;
101 |         i = d[num].ct;
102 |         p[k].left = p[k].left-t;
103 |         num++;
104 |         for(j=0;j<n;j++)
105 |         {
106 |           if(p[j].status==0 && p[j].at<=i)
107 |           {
108 |             enqueue(j);
109 |             p[j].status = 1;
110 |           }
111 |         }
112 |         enqueue(k);
113 |       }
114 |     }
115 |     else
116 |     {
117 |       i++;
118 |     }
119 |   }
120 | 
121 |   printf("\nPROCESS NAME\tCOMPLETION TIME (ms)\tWAITING TIME (ms)\tTURNAROUND TIME (ms)\n\n");
122 |   for(i=0;i<n;i++)
123 |   {
124 |     printf("    %s\t\t\t%d\t\t\t%d\t\t\t%d\n",p[i].name,p[i].ct,p[i].wt,p[i].tt);
125 |     avwt+=p[i].wt;
126 |     avtt+=p[i].tt;
127 |   }
128 |   printf("\n\nGANTT CHART ");
129 |   printf("\n\t--------------------------------------------------------------------------\n\t");
130 |   for(i=0;i<num;i++)
131 |   {
132 |     printf("|");
133 |     printf("%s\t",d[i].name);
134 |   }
135 |   printf(" |");
136 |   printf("\n\t--------------------------------------------------------------------------\n\t");
137 |   for(i=0;i<num;i++)
138 |   {
139 |       printf("%d\t",d[i].st);
140 |   }
141 |   printf("%d\t",d[num-1].ct);
142 |   printf("\n\nAVERAGE WAITING TIME : %f",(avwt/n));
143 |   printf("\nAVERAGE TURNAROUND TIME : %f\n",(avtt/n));
144 | }
145 | 


--------------------------------------------------------------------------------
/Deadlock_Avoidance/bankers.c:
--------------------------------------------------------------------------------
  1 | #include<stdio.h>
  2 | #include<string.h>
  3 | #include<stdlib.h>
  4 | 
  5 | int avail[100];
  6 | int resmax[100];
  7 | int maxalloc[100];
  8 | int req[100];
  9 | struct process
 10 | {
 11 |   char name[100];
 12 |   int max[100];
 13 |   int alloc[100];
 14 |   int need[100];
 15 |   int done;
 16 | }p[20],temp;
 17 | void main()
 18 | {
 19 |   int i,j,r,pr,flag,ls,ml=0,g=0,id;
 20 |   char name[100],str[100] = "";
 21 |   printf("ENTER THE NUMBER OF RESOURCES : ");
 22 |   scanf("%d",&r);
 23 |   printf("MAXIMUM RESOURCE COUNT FOR : \n");
 24 |   for(j=0;j<r;j++)
 25 |   {
 26 |     printf("\tRESOURCE %d : ",j+1);
 27 |     scanf("%d",&resmax[j]);
 28 |   }
 29 |   printf("\nENTER THE NUMBER OF PROCESSES : ");
 30 |   scanf("%d",&pr);
 31 |   for(i=0;i<pr;i++)
 32 |   {
 33 |     printf("\nENTER PROCESS NAME : ");
 34 |     scanf(" %s",p[i].name);
 35 |     printf("\nDETAILS FOR PROCESS %s",p[i].name);
 36 |     for(j=0;j<r;j++)
 37 |     {
 38 |       printf("\n\tMAXIMUM ALLOCATION FOR RESOURCE %d : ",j+1);
 39 |       scanf("%d",&p[i].max[j]);
 40 | 
 41 |       printf("\tALLOCATED RESOURCE FOR RESOURCE %d : ",j+1);
 42 |       scanf("%d",&p[i].alloc[j]);
 43 | 
 44 |       maxalloc[j] = maxalloc[j] + p[i].alloc[j];
 45 |       p[i].need[j] = p[i].max[j] - p[i].alloc[j];
 46 |     }
 47 |     p[i].done = 0;
 48 |   }
 49 |   for (i=0;i<r;i++)
 50 |   {
 51 |     avail[i] = resmax[i] - maxalloc[i];
 52 |   }
 53 |   printf("\nENTER THE NEW REQUEST :-  \n\n");
 54 |   printf("ENTER THE PROCESS NAME : ");
 55 |   scanf("%s",name);
 56 |   for(j=0;j<r;j++)
 57 |   {
 58 |       printf("\tREQUEST FOR RESOURCE %d : ",j+1);
 59 |       scanf("%d",&req[j]);
 60 |   }
 61 |   for (i=0;i<pr;i++)
 62 |   {
 63 |       if(strcmp(p[i].name,name)==0)
 64 |       {
 65 |           id = i;
 66 |           break;
 67 |       }
 68 |   }
 69 |   for(flag=0,i=0;i<r;i++)
 70 |   {
 71 |       if(req[i] <= p[id].need[i])
 72 |       {
 73 |           flag++;
 74 |       }
 75 |   }
 76 |   if(flag !=r)
 77 |   {
 78 |       printf("RESOURCE NOT GRANTED!! \nREQUESTED RESOURCE GREATER THAN NEEDED");
 79 |       exit(0);
 80 |   }
 81 |   else if(flag == r)
 82 |   {
 83 |       for(i=0;i<r;i++)
 84 |       {
 85 |           p[id].alloc[i] =  p[id].alloc[i] + req[i];
 86 |           p[id].need[i] =  p[id].need[i] - req[i];
 87 |           avail[i] = avail[i] - req[i];
 88 |       }
 89 |   }
 90 |   printf("\n  PROCESS \tMAXIMUM \tALLOCATED \tREMAINING\n");
 91 |   for(i=0;i<pr;i++)
 92 |   {
 93 |     printf("\n     %s      \t ",p[i].name);
 94 |     for(j=0;j<r;j++)    //Max
 95 |     {
 96 |       printf("%d ",p[i].max[j]);
 97 |     }
 98 |     printf(" \t  ");
 99 |     for(j=0;j<r;j++)    //Alloc
100 |     {
101 |       printf("%d ",p[i].alloc[j]);
102 |     }
103 |     printf("\t  ");
104 |     for(j=0;j<r;j++)    //Need
105 |     {
106 |       printf("%d ",p[i].need[j]);
107 |     }
108 |   }
109 | 
110 |   printf("\n\nORDER OF EXECUTION :- \n");
111 |   for(i=0,ls=0;ls<pr;)
112 |   {
113 |     for(flag = 0,j=0;j<r;j++)
114 |     {
115 |       if(avail[j]>=p[i].need[j])
116 |       {
117 |         flag++;
118 |       }
119 |     }
120 |     if(flag == r && p[i].done == 0)
121 |     {
122 |       p[i].done = ls+1;
123 |       for(ml=0,j=0;j<r;j++)
124 |       {
125 |         avail[j] = avail[j] + p[i].alloc[j];
126 |         if(avail[j]==resmax[j])
127 |         {
128 |           ml++;
129 |         }
130 |       }
131 |       g++;
132 |       ls++;
133 |       printf("\t\t%s IS VISTED \n",p[i].name);
134 |       strcat(str,p[i].name);
135 |       strcat(str,", ");
136 |     }
137 |     else
138 |     {
139 |       i++;
140 |       if(i==pr)
141 |       {
142 |         if(g==0)
143 |         {
144 |           printf("\t\tREQUEST NOT ALLOCATED -- DEADLOCK OCCURED\n");
145 |           break;
146 |         }
147 |         i=0;
148 |         g=0;
149 |       }
150 |     }
151 |   }
152 |   if(ml==r && ls == pr)
153 |   {
154 |     printf("\nSYSTEM IS IN SAFE STATE\n");
155 |     printf("\nSAFE STATE SEQUENCE : %s",str);
156 |     printf("\b\b.  \n");
157 |   }
158 |   else if(g==0)
159 |   {
160 |     printf("\nSYSTEM IS IN UNSAFE STATE\n");
161 |   }
162 | }
163 | 


--------------------------------------------------------------------------------