-
Notifications
You must be signed in to change notification settings - Fork 0
/
Process.c
157 lines (139 loc) · 4.04 KB
/
Process.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
//
// Process.c
// T1
//
// Created by Guillermo Figueroa and Juan Cortés on 8/16/17.
// Copyright © 2017 Guillermo Figueroa and Juan Cortés. All rights reserved.
//
#include "Process.h"
#include <stdlib.h>
int next_pid = 0;
Process* init_process(char name[], int priority, int initial_time, int times_size, int* times){
Process* process = malloc(sizeof(Process));
process -> pid = next_pid;
next_pid += 1;
int i;
for (i = 0; i < NAME_SIZE; i++){
process -> name[i] = name[i];
}
process -> size_times = times_size;
process -> times = times;
process -> qk = 0;
process -> actual_time = 0;
process -> time_executed = 0;
process -> total_time_waiting = 0;
process -> initial_time = initial_time;
process -> priority = 64 - priority;
process -> state = READY;
process -> response_time = -1;
process -> turnaround_time = -1;
process -> blocked = 0;
process -> chosen = 0;
process -> total_time_waiting = 0;
return process;
}
/*
* 1 if the change was succesfull
* 0 otherwise
*/
int change_state(Process* process, int state){
switch (state) {
case RUNNING:
process -> state = RUNNING;
process -> chosen++;
return 1;
case WAITING:
if (process -> state == RUNNING){
process -> actual_time++;
if (process -> actual_time >= process -> size_times){
process_finished++;
process -> turnaround_time = stime - process -> initial_time;
process -> time_executed = 0;
printf("FINISHED " BLUE "%s" RESET " | ", process -> name);
return 0;
}
process -> blocked++;
process -> state = WAITING;
} else {
printf("Error on changing the state to waiting by the process:\n");
return 0;
}
return 1;
case READY:
if (process -> state == WAITING){
process -> actual_time++;
process -> state = READY;
return 1;
} else if (process -> state == RUNNING){
process -> state = READY;
return 1;
} else {
printf("Error on changing the state to ready by the process:\n");
return 0;
}
break;
default:
return 0;
}
}
int intervals_executed(Process* process){
if(!process) {return 0;}
return process -> actual_time/2;
}
int intervals_left(Process* process){
if(!process) {return 0;}
int val = (process -> size_times + 1)/2;
return val - intervals_executed(process);
}
int total_executing_time(Process* process){
if (!process){
return 0;
}
int pos = process -> actual_time;
int total = 0;
int i;
for (i = 0; i < pos; i+=2){
total += process -> times[i];
}
total += process -> time_executed;
return total;
}
int max_current_time_process(Process* process){
if (process){
int pos = process -> actual_time;
int max_time = process -> times[pos];
return max_time;
}
return 0;
}
void print_process(Process* process){
printf("going to print\n");
if (process == NULL){
printf("This process is empty\n");
return;
}
printf("PID: %d\nNAME: %s\nINITIAL_TIME: %d\nPRIORITY: %d\nQk: %d\nSTATE: %d\nSIZE TIMES: %d\n",
process->pid,
process->name,
process->initial_time,
process->priority,
process->qk,
process->state,
process->size_times);
int i;
for (i = 0; i < process -> size_times; i++){
printf("TIME%d: %d\n", i, process->times[i]);
}
printf("\n");
}
void free_process(Process* process){
free(process->times);
free(process);
}
void free_process_array(Process** process_array, int size){
int i;
for (i = 0; i < size; i++){
free_process(process_array[i]);
}
free(process_array);
}