├── Basic-1
├── Basic2
├── Basic3
├── Final Project
├── FinalProgram
├── README.md
└── os1.cpp


/Basic-1:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | 
 3 | struct process
 4 | {
 5 |       char process_name;
 6 |       int arrival_time, burst_time, ct, waiting_time, turnaround_time, priority;
 7 |       int status;
 8 | }process_queue[10];
 9 | 
10 | int limit;
11 | 
12 | void Arrival_Time_Sorting()
13 | {
14 |       struct process temp;
15 |       int i, j;
16 |       for(i = 0; i < limit - 1; i++)
17 |       {
18 |             for(j = i + 1; j < limit; j++)
19 |             {
20 |                   if(process_queue[i].arrival_time > process_queue[j].arrival_time)
21 |                   {
22 |                         temp = process_queue[i];
23 |                         process_queue[i] = process_queue[j];
24 |                         process_queue[j] = temp;
25 |                   }
26 |             }
27 |       }
28 | }
29 | 


--------------------------------------------------------------------------------
/Basic2:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | 
 3 | struct process
 4 | {
 5 |       char process_name;
 6 |       int arrival_time, burst_time, ct, waiting_time, turnaround_time, priority;
 7 |       int status;
 8 | }process_queue[10];
 9 | 
10 | int limit;
11 | 
12 | void Arrival_Time_Sorting()
13 | {
14 |       struct process temp;
15 |       int i, j;
16 |       for(i = 0; i < limit - 1; i++)
17 |       {
18 |             for(j = i + 1; j < limit; j++)
19 |             {
20 |                   if(process_queue[i].arrival_time > process_queue[j].arrival_time)
21 |                   {
22 |                         temp = process_queue[i];
23 |                         process_queue[i] = process_queue[j];
24 |                         process_queue[j] = temp;
25 |                   }
26 |             }
27 |       }
28 | }
29 | 
30 | void main()
31 | {
32 |       int i, time = 0, burst_time = 0, largest;
33 |       char c;
34 |       float wait_time = 0, turnaround_time = 0, average_waiting_time, average_turnaround_time;
35 |       printf("\nEnter Total Number of Processes:\t");
36 |       scanf("%d", &limit);
37 |       for(i = 0, c = 'A'; i < limit; i++, c++)
38 |       {
39 |             process_queue[i].process_name = c;
40 |             printf("\nEnter Details For Process[%C]:\n", process_queue[i].process_name);
41 |             printf("Enter Arrival Time:\t");
42 |             scanf("%d", &process_queue[i].arrival_time );
43 |             printf("Enter Burst Time:\t");
44 |             scanf("%d", &process_queue[i].burst_time);
45 |             printf("Enter Priority:\t");
46 |             scanf("%d", &process_queue[i].priority);
47 |             process_queue[i].status = 0;
48 |             burst_time = burst_time + process_queue[i].burst_time;
49 |       }
50 | 


--------------------------------------------------------------------------------
/Basic3:
--------------------------------------------------------------------------------
 1 | Arrival_Time_Sorting();
 2 |       process_queue[9].priority = -9999;
 3 |       printf("\nProcess Name\tArrival Time\tBurst Time\tPriority\tWaiting Time");
 4 |       for(time = process_queue[0].arrival_time; time < burst_time;)
 5 |       {
 6 |             largest = 9;
 7 |             for(i = 0; i < limit; i++)
 8 |             {
 9 |                   if(process_queue[i].arrival_time <= time && process_queue[i].status != 1 && process_queue[i].priority > process_queue[largest].priority)
10 |                   {
11 |                         largest = i;
12 |                   }
13 |             }
14 |             time = time + process_queue[largest].burst_time;
15 |             process_queue[largest].ct = time;
16 |             process_queue[largest].waiting_time = process_queue[largest].ct - process_queue[largest].arrival_time - process_queue[largest].burst_time;
17 |             process_queue[largest].turnaround_time = process_queue[largest].ct - process_queue[largest].arrival_time;
18 |             process_queue[largest].status = 1;
19 |             wait_time = wait_time + process_queue[largest].waiting_time;
20 |             turnaround_time = turnaround_time + process_queue[largest].turnaround_time;
21 |             printf("\n%c\t\t%d\t\t%d\t\t%d\t\t%d", process_queue[largest].process_name, process_queue[largest].arrival_time, process_queue[largest].burst_time, process_queue[largest].priority, process_queue[largest].waiting_time);
22 |       }
23 |       average_waiting_time = wait_time / limit;
24 |       average_turnaround_time = turnaround_time / limit;
25 |       printf("\n\nAverage waiting time:\t%f\n", average_waiting_time);
26 |       printf("Average Turnaround Time:\t%f\n", average_turnaround_time);
27 | }
28 | 


--------------------------------------------------------------------------------
/Final Project:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | 
 3 | struct process
 4 | {
 5 |       char process_name;
 6 |       int arrival_time, burst_time, ct, waiting_time, turnaround_time, priority;
 7 |       int status;
 8 | }process_queue[10];
 9 | 
10 | int limit;
11 | 
12 | void Arrival_Time_Sorting()
13 | {
14 |       struct process temp;
15 |       int i, j;
16 |       for(i = 0; i < limit - 1; i++)
17 |       {
18 |             for(j = i + 1; j < limit; j++)
19 |             {
20 |                   if(process_queue[i].arrival_time > process_queue[j].arrival_time)
21 |                   {
22 |                         temp = process_queue[i];
23 |                         process_queue[i] = process_queue[j];
24 |                         process_queue[j] = temp;
25 |                   }
26 |             }
27 |       }
28 | }
29 | 
30 | void main()
31 | {
32 |       int i, time = 0, burst_time = 0, largest;
33 |       char c;
34 |       float wait_time = 0, turnaround_time = 0, average_waiting_time, average_turnaround_time;
35 |       printf("\nEnter Total Number of Processes:\t");
36 |       scanf("%d", &limit);
37 |       for(i = 0, c = 'A'; i < limit; i++, c++)
38 |       {
39 |             process_queue[i].process_name = c;
40 |             printf("\nEnter Details For Process[%C]:\n", process_queue[i].process_name);
41 |             printf("Enter Arrival Time:\t");
42 |             scanf("%d", &process_queue[i].arrival_time );
43 |             printf("Enter Burst Time:\t");
44 |             scanf("%d", &process_queue[i].burst_time);
45 |             printf("Enter Priority:\t");
46 |             scanf("%d", &process_queue[i].priority);
47 |             process_queue[i].status = 0;
48 |             burst_time = burst_time + process_queue[i].burst_time;
49 |       }
50 |       Arrival_Time_Sorting();
51 |       process_queue[9].priority = -9999;
52 |       printf("\nProcess Name\tArrival Time\tBurst Time\tPriority\tWaiting Time");
53 |       for(time = process_queue[0].arrival_time; time < burst_time;)
54 |       {
55 |             largest = 9;
56 |             for(i = 0; i < limit; i++)
57 |             {
58 |                   if(process_queue[i].arrival_time <= time && process_queue[i].status != 1 && process_queue[i].priority > process_queue[largest].priority)
59 |                   {
60 |                         largest = i;
61 |                   }
62 |             }
63 |             time = time + process_queue[largest].burst_time;
64 |             process_queue[largest].ct = time;
65 |             process_queue[largest].waiting_time = process_queue[largest].ct - process_queue[largest].arrival_time - process_queue[largest].burst_time;
66 |             process_queue[largest].turnaround_time = process_queue[largest].ct - process_queue[largest].arrival_time;
67 |             process_queue[largest].status = 1;
68 |             wait_time = wait_time + process_queue[largest].waiting_time;
69 |             turnaround_time = turnaround_time + process_queue[largest].turnaround_time;
70 |             printf("\n%c\t\t%d\t\t%d\t\t%d\t\t%d", process_queue[largest].process_name, process_queue[largest].arrival_time, process_queue[largest].burst_time, process_queue[largest].priority, process_queue[largest].waiting_time);
71 |       }
72 |       average_waiting_time = wait_time / limit;
73 |       average_turnaround_time = turnaround_time / limit;
74 |       printf("\n\nAverage waiting time:\t%f\n", average_waiting_time);
75 |       printf("Average Turnaround Time:\t%f\n", average_turnaround_time);
76 | }
77 | 


--------------------------------------------------------------------------------
/FinalProgram:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | 
 3 | struct process
 4 | {
 5 |       char process_name;
 6 |       int arrival_time, burst_time, ct, waiting_time, turnaround_time, priority;
 7 |       int status;
 8 | }process_queue[10];
 9 | 
10 | int limit;
11 | 
12 | void Arrival_Time_Sorting()
13 | {
14 |       struct process temp;
15 |       int i, j;
16 |       for(i = 0; i < limit - 1; i++)
17 |       {
18 |             for(j = i + 1; j < limit; j++)
19 |             {
20 |                   if(process_queue[i].arrival_time > process_queue[j].arrival_time)
21 |                   {
22 |                         temp = process_queue[i];
23 |                         process_queue[i] = process_queue[j];
24 |                         process_queue[j] = temp;
25 |                   }
26 |             }
27 |       }
28 | }
29 | 
30 | void main()
31 | {
32 |       int i, time = 0, burst_time = 0, largest;
33 |       char c;
34 |       float wait_time = 0, turnaround_time = 0, average_waiting_time, average_turnaround_time;
35 |       printf("\nEnter Total Number of Processes:\t");
36 |       scanf("%d", &limit);
37 |       for(i = 0, c = 'A'; i < limit; i++, c++)
38 |       {
39 |             process_queue[i].process_name = c;
40 |             printf("\nEnter Details For Process[%C]:\n", process_queue[i].process_name);
41 |             printf("Enter Arrival Time:\t");
42 |             scanf("%d", &process_queue[i].arrival_time );
43 |             printf("Enter Burst Time:\t");
44 |             scanf("%d", &process_queue[i].burst_time);
45 |             printf("Enter Priority:\t");
46 |             scanf("%d", &process_queue[i].priority);
47 |             process_queue[i].status = 0;
48 |             burst_time = burst_time + process_queue[i].burst_time;
49 |       }
50 |       Arrival_Time_Sorting();
51 |       process_queue[9].priority = -9999;
52 |       printf("\nProcess Name\tArrival Time\tBurst Time\tPriority\tWaiting Time");
53 |       for(time = process_queue[0].arrival_time; time < burst_time;)
54 |       {
55 |             largest = 9;
56 |             for(i = 0; i < limit; i++)
57 |             {
58 |                   if(process_queue[i].arrival_time <= time && process_queue[i].status != 1 && process_queue[i].priority > process_queue[largest].priority)
59 |                   {
60 |                         largest = i;
61 |                   }
62 |             }
63 |             time = time + process_queue[largest].burst_time;
64 |             process_queue[largest].ct = time;
65 |             process_queue[largest].waiting_time = process_queue[largest].ct - process_queue[largest].arrival_time - process_queue[largest].burst_time;
66 |             process_queue[largest].turnaround_time = process_queue[largest].ct - process_queue[largest].arrival_time;
67 |             process_queue[largest].status = 1;
68 |             wait_time = wait_time + process_queue[largest].waiting_time;
69 |             turnaround_time = turnaround_time + process_queue[largest].turnaround_time;
70 |             printf("\n%c\t\t%d\t\t%d\t\t%d\t\t%d", process_queue[largest].process_name, process_queue[largest].arrival_time, process_queue[largest].burst_time, process_queue[largest].priority, process_queue[largest].waiting_time);
71 |       }
72 |       average_waiting_time = wait_time / limit;
73 |       average_turnaround_time = turnaround_time / limit;
74 |       printf("\n\nAverage waiting time:\t%f\n", average_waiting_time);
75 |       printf("Average Turnaround Time:\t%f\n", average_turnaround_time);
76 | }
77 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # OperatingSystem
2 | 4th Semester Operating System Projects
3 | 


--------------------------------------------------------------------------------
/os1.cpp:
--------------------------------------------------------------------------------
  1 | #include<stdio.h>
  2 | #include<pthread.h>
  3 | #include<time.h>
  4 | #include<assert.h>
  5 | #define MIN_PID 100
  6 | #define MAX_PID 1000
  7 | pthread_mutex_t Lock;
  8 | struct process 
  9 |            {
 10 | 		int pid, isAllocated;
 11 | 	            }obj[MAX_PID-MIN_PID];
 12 | 	
 13 | 	int allocate_map() 
 14 |    {
 15 | 		int i=MIN_PID;
 16 | 		while(i<=MAX_PID)
 17 |            {
 18 | 			obj[i-MIN_PID].pid=i;
 19 | 			obj[i-MIN_PID].isAllocated=0;
 20 | 			i++;
 21 | 		}
 22 | 		return 1;
 23 | 	}
 24 | 	
 25 | 	int allocate_pid()
 26 |    {
 27 | 		int i=0;
 28 | 		while(i<MAX_PID)
 29 |         {
 30 | 			if (obj[i]. isAllocated==0) 
 31 |                        {
 32 | 				pthread_mutex_lock(&Lock);
 33 | 				obj[i]. isAllocated=1;
 34 | 				pthread_mutex_unlock(&Lock);
 35 | 				return obj[i].pid;
 36 | 			}
 37 | 			i++;
 38 | 		}
 39 | 		return -1;
 40 | 	}
 41 | 	
 42 | 	void release_pid(int pid) 
 43 | {
 44 | 		int i=0;
 45 | 		while(i<MAX_PID) 
 46 |           {
 47 | 			if(obj[i]. pid==pid) 
 48 |                        {
 49 | 				int res=pthread_mutex_lock(&Lock);
 50 |                                     if(res==0)
 51 |                                    {
 52 |                                     printf("Aborting the process as res==0");
 53 |                                     } 
 54 |             				assert(res==0);
 55 | 				obj[i]. isAllocated=0;
 56 | 				res=pthread_mutex_unlock(&Lock);
 57 | 				break;
 58 | 			}
 59 | 			i++;
 60 | 		}
 61 | 	}
 62 | 	
 63 | 	void* Func(void *args) 
 64 | {
 65 | 		int pid=allocate_pid();
 66 | 		printf("New process created: %d\n",pid);
 67 | 		int time=(rand()+20)%(40+1);
 68 | 		release_pid(pid);
 69 | 		printf("Process destroyed with pid: %d\n",pid);
 70 | 	}
 71 | 	
 72 | 	
 73 | 	void createProcess() 
 74 | {
 75 | 		int i=0,n;
 76 |             printf("How many threads");
 77 |             scanf("%d",&n);
 78 | 		pthread_t threadPid[n];
 79 | 		if(pthread_mutex_init(&Lock,NULL)!=0)
 80 | 			printf("Mutex init.");
 81 | 		while(i<n) 
 82 |            {
 83 | 			pthread_create(&threadPid[i],NULL,Func,NULL);
 84 | 			i++;
 85 | 		}
 86 | 	
 87 | 		i=0;
 88 | 		while(i<n) 
 89 |            {
 90 | 			pthread_join(threadPid[i],NULL);
 91 | 			i++;
 92 | 		}	
 93 | 	
 94 | 	
 95 |                 }			      
 96 |     int main() 
 97 | 	{
 98 |  	if(allocate_map()) 
 99 |            {
100 | 		srand(time(0));
101 | 		createProcess();
102 | 		}
103 | 		return 0;
104 | 	}
105 | 	
106 | 


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