-
Notifications
You must be signed in to change notification settings - Fork 0
/
concept.txt
199 lines (155 loc) · 3.23 KB
/
concept.txt
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
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
pthread for every philo
time usleep!!! philos need delay for right work, so they
don't grab things simultaneusly
algo: (deixtra?)
forks numbered
philos numbered
philo takes not left fork, but fork with SMALLER number:
p1 f1
p2 f2
p3 f3
p4 f4
p5 f1 (if 4 will take one, he will wait, because he tries to get this first ANYWAY)
DEADLOCK PREVENTION
take forks in order: min->max
leave forks in order: max->min
(locks problem)
----
for..
pthread_cread( , ,philo_routine,data)
//philo_routine: work of philosophers
//data: time, *forks[2]...
detach/pthread_join
join: only on the end of main program
---
in main thread:
while(1)
for philo in philosophers
if (is_died(philo))
check if any philo is dead, simulation stops
clean all data, return
EXIT IS FORBIDDEN!!!!!! only for bonus part
only return in a main()
---
pthread_mutex_init ->
-> mutex_destroy not needed in our case?
possible after all join's are done
---
ptherads existing in one process,
so they share same information,
it's easier to share information
"cheating" is possible
philos can communicate somehow
---
void *philo(void * data)
{
while (1)
{
lock(min_f)
printf(philo took fork)
left(max_f)
printf(philo took fork)
printf(philo eating)
usleep (time to eat * 1000)
unlock
unlock
printf(sleeping)
usleep( time_to_sleep)
printf(thinking)
}
}
thinking - mutex locked,
not possible to lock one more
thinking
---
usleep - need * 1000
while init - * 1000 while saving data into structure
---
stdio should be protected
printf will be mixed,
every thread will try to printf in the sama time (also data race?)
printf
1 global mutex to protext stdio which we are using before/after printing
---
void *philo(void * data)
{
//numerate philo first in *data!!
if (data->philo_id % 2 == 0
usleep(2500))
// ~half of philos will come later to the table
while (1)
{
lock(min_f)
printf(philo took fork)
left(max_f)
printf(philo took fork)
printf(philo eating)
usleep (time to eat * 1000)
unlock
unlock
printf(sleeping)
usleep( time_to_sleep)
printf(thinking)
}
}
cannot add is_died check into "void philo" function
---
is_died(philo)
struct philo
{
time_to_die
time_to_sleep
time_to_eat
mutex *left (or min idx)
mutex *right (or max idx)
struct timeval last_eating_time
}
---
struct timeval last_eating_time
int gettimeofday(struck timeval *)
struct timeval
{
long tv_sec //global time from 1970
long tv_usec //time inbetween (0, 1000000)
}
tv_sec * 1000 + tv_usec /1000 - CURRENT TIME
get current time
extract time of lastmeal
if > time to die
is_died returns (1)
simulation stops
void *philo(void * data)
{
//numerate philo first in *data!!
if (data->philo_id % 2 == 0
usleep(2500))
// ~half of philos will come later to the table
while (1)
{
lock(min_f)
printf(philo took fork)
left(max_f)
printf(philo took fork)
printf(philo eating)
time of last meal
usleep (time to eat * 1000)
unlock
unlock
printf(sleeping)
usleep( time_to_sleep)
printf(thinking)
}
}
---
add must_die to philo_struct,
protect must_die with mutex
void philo - while (1)
checks first is must_die = 1, then thread stops before starting
---
after must_die = 1
thread_join
free everything
main stops as last one
---
---
usleep works not 100% correct