Zarządzanie procesami

‘
{u}|
q
bufor
w buforze – trzeba
proces
"producent"
Ž
‰–
—
„• ”
‚“’
G
o
: 3
:1D 9
: 3
>
o
c
b
db
ml
k
jf
`
]
gf
ih
\
^
\e
a
d d a
c
b
a
VW
YZX
^ ]
`
^_
^]
\ [
U
O
&
O
T
M
$
$
,
*
RS
"Q
P
N
%
M KL
<2
E
E
/
/
5
B
:
.
-7
:D >
: /
:
0
B.D
F
:; 3
:
;.
3
C
/
2 3
9
B
:
0D >
-
6 ?
5
C
. >
?A
JI>
7
B
2
<
@
0 @H
<
=-7
G
drukarka, ale bez spool-ingu)
 €

=
=
:
=-7
2
5 A
B
:
.
-7
H
W
10/
<
1:89
. >
:- 3
6 ?
5
. >
=-7
<;
.
-7
5163
14/
20 3
-.
$
"
!
!
"
'
& "
,
"
+
)
*
(
'
& "
%
$ #
!
• procesy
qz
pxy
proces
"konsument"
uwv
uts
gdy bufor pusty
wstrzymuj
konsumenta
r
0
-7
- A
5
•
<B
2
• przez (
pq
u‹Š
>
0 @H
–
Œ ‡
‰„
uˆ‡
‚†…
<
=17n
–
Œ ‡
Ž„
ƒ„
‚€
u~
•
Œ
„

zasobów krytycznych, czyli takich do
problem producenta & konsumenta) :
wstrzymuj
producenta
-
<;:
7
9 6
7
78
5
>*= 0
3
5
7 6
2
l1: ax:= licznik
l2: ax:= ax + 1
l3: licznik:= ax
3
56
-,
7
2
/0
*
Proces P1:
for i:=1 to 10 do
begin
licznik:=licznik+1
end
)*
'
'
Odp
synchronizacja procesów
odpowiednich momentach (i wznawianie)
+
4
32
1
.
-,
Proces P0:
for i:=1 to 10 do
begin
licznik:=licznik+1
end
+
+
+
•
%
$#
#
"
!
•
•
&%
•
•
(
$
z dzielenie"
peracyjnej
zasobem krytycznym)
P0 i P1
licznik:=0
l1: ax:= licznik
l2: ax:= ax + 1
l3: licznik:= ax
P0 i P1 licznik=20
#
B
<
&
&
!
B
$
$E
" $
<
#
"
&D
&
$
!
B
&
to jeden z nich zostanie wpuszczony
• ograniczone czekanie
&
$
<
#
$
#
B
C "
$
#
$C
#
<
=
?
A@
$#
#
<
$
<
;
1
31
7+
*
,
.
4
2
8
+ 5
)
71
7
8
,
2
*)
*
8
) 2
1
7+
3.
- 8
1
7
8
,
8
2
,
:
9
+
1
)
+
1
3+
*
*
3
+
71
*)
*
2
.
- ,
) 2
/
1
0
+
2
/
-.,
+
)
2
6
5
- ,
3+
*
4
*)
3
*
*
– mamy n procesów: P0, P1, ... , P{n-1}
zasobu krytycznego;
–
fragmenty te nazywamy sekcjami krytycznymi (np. w problemie prod&kons
&
"
'
%
(
#
$
#
(posiadany) przez co
prod&kons, zmienna "licznik", lista elementów)
"!
– zasób krytyczny
F
#
•
=>
7
–
•
•
zasobu krytycznego = problem sekcji krytycznej
def problemu sekcji krytycznej
ia:
• wzajemne wykluczanie procesów
*
'& *32/4
(+*)
.-, 5/& 2 46
0 7&
5*
%& (1
398
-0
: 71
;&
1<
51
46
=
0&
(1 &%
32/ &
* 4 '(+*)
51 46 .-,
2 7& /&
0
5*
$
Proces P0:
repeat
sekcja krytyczna
! #" !
#"
i
A: 0
kodzie programu (
41
) ; )1 @: & ' 5 A37
'B 41 @% & 1 C? ;
(1 DE@ / - / D ) >
-
9&@ ?
–
–
5@* FI3G H
)& 6 K3J
=82 NLK M
&
;* 5* 0
; 71 :1 4
(21 4 2 O
5 7?7
D :%9 *3/
- 0 * <0
;* /&
-; @; P
@% R *3/
&2 %*
1 Q3; 7
(&@ 2
ST & 7
%1@
*2
-4
:1
4
;*
•
•
)
jej zadaniem jest
wstrzymywanie procesu
sek. kryt.)
until false
algorytm Petersena
tylko dla 2 procesów P0 i P1 !!!
– zmienne pomocnicze (globalne/ dzielone) : [zainicjowane zerami !]
flag: array[0..1] of integer,
turn: integer;
algorytm Petersena aktywne czekanie
(to wada !)
until false
"
!
#!
-%
+
+
!
#
3
1
2
1
4+ !
$
!
% %
0
4 !$
-
$
P0 i P1
!
! # !
! ,
#!
# !
!
!
# .
#
+ /
!
#
# !
"
$
#
!
• ograniczone czekanie –
#!
$
# "
$
!
$
#
!
$!
!
"
%
!
# "
$
!
#
!
!
,
+
.
!
# &
(
-
&'
* )
!
• wzajemne wykluczanie • gdy P0 przebywa w sekcji krytycznej a P1
• gdy P0 i P1
•
–
flag[1]=1 and turn=0) i (flag[0]=1 and turn=1
# until false
flag[1]:=1;
turn:=1;
while flag[0]=1 and turn=1 do nic;
sekcja krytyczna
flag[1]:=0;
flag[0]:=1;
turn:=0;
while flag[1]=1 and turn=0 do nic;
sekcja krytyczna
flag[0]:=0;
Proces P1:
repeat
Proces P0:
repeat
P0 i P1 !)
(
E
D
C
,
A
;
:
B
A
,
9
M
P
J O
H
N
F
T
T
H
OT
M
N
M
S
J F
O
G MJ
JH
L
@
<
:
=
2
?
:
1
./
<
+
K F
F
R
L
J
Q
H
H
G
1. procesor wykonuje P1
2. P0 wchodzi do sekcji krytycznej (turn=0)
3. procesor wraca do P1
F
=
P0 i P1
9
* 2
=
<*
J+
I :
F
1
; 3
89 7
+
5 34
+
-
6
1
.
2-
-
0
>
until false
.
./
,-
until false
* )
+
%&$
$
turn:=1;
flag[1]:=1;
while flag[0]=1 and turn=1 do nic;
sekcja krytyczna
flag[1]:=0;
turn:=0;
flag[0]:=1;
while flag[1]=1 and turn=0 do nic;
sekcja krytyczna
flag[0]:=0;
Proces P1:
repeat
Proces P0:
repeat
#
"
!
'
drobna zmiana w algorytmie Petersena
•
algorytm Petersena c.d.
P0
: 1
?
8 4
<
@ +
6
.*1
:
-
.51
2 <
9
;
82
2 4
6
-
@A9?
D
D
D
03
2
/2
.G4
C?
F
)
;
- 4
3
)>* =
7.6 4
2
:
5 <
;
?
;()
)
* 9
6
*
)
2 +
:
-
i krytycznej
32
)
-
;()
H
D
0
6
C
- 1
()*
0 9
8
?
)
C
!
7.6 4
-
6
E
D ?
5.1
32 4
8
0 9
2.1
(
*
0 C
3
-
,
* ?
0/
-.+,
4
B,
()*
/
*
–
–
w obszarze sek. kryt
&
$
%&
!"
$#
'
•
•
4
K
+
6
@
*
2
D
0
; C
?
)
6
E
D ?
J
-
:
* 4
GF
B
)
32
;
2
B
G
/
*
- 4
G
I.29
32
– intel 8086: cli -przerwania zakazane, sti –przerwania dozwolone
sek.kryt. zasobu B
–
Q
9
* ?
0 <
62
*
;(
C
Proces Pi:
repeat
*
9
* ?
0 <
62
*
C
while TestAndSet(zamek) do nic;
sekcja krytyczna
zamek:=false;
;(
def rozkazu TestAndSet:
function TestAndSet(var cel:boolean)
:boolean;
begin
TestAndSet:=cel;
cel:=true;
end
R
VUST
:
zamek:=false;
NOP
LM
specjalne rozkazy procesora, np. TestAndSet():
*
l
k
Vgf
`
^e\
c d
^b`
Y Z
Z`
] _
^]\
V[Z
until false
e
Y
hi
cj
a
[
aY
]
.YX
Uwaga 1
Uwaga 2: nie ma gwarancji ograniczonego czekania !
W
•
problem producenta/ konsumenta
• aktywnym czekaniem
ilosc
bufor
proces
"producent"
proces
"konsument"
czyt
pisz
n
Proces Producent:
repeat
produkuje element "elem"
while ilosc=n do nic;
bufor[pisz]:=elem;
pisz:=(pisz+1) mod n;
ilosc:=ilosc+1;
until false
Proces Konsument:
repeat
while ilosc=0 do nic;
elem:=bufor[czyt];
czyt:=(czyt+1) mod n;
ilosc:=ilosc-1;
konsumuje element "elem"
until false
wzajemne wykluczanie !!!
(to jest sekcja krytyczna)
1
B
18
(
%
F G
IJ
9
M
T%S
R
H
QM
U
QM
E
F P
N
V
A
HB
F
:
F N
<
•
E
K
M
OJ
9
E
F P
N
A
HB
F
:
F N
<
E
L
K
M
OJ
L
E
B
CB
?
<
mamy n- procesów P0, P1, ..., P{n-1
sekcji krytycznej ...
zmienne globalne:
wybrane: array[0..n-1] of boolean
numer: array[0..n-1] of integer
specjalna relacja "<": (a,b) < (c,d) a<c lub (a=c i b<d)
•
' 1
&0
;
H G
D
%
F D
2
)(
#
0
7 #
%
&
)
=>
%
A @
"
0
2
'
;
: 9
•
,
(
!'
dla wielu procesów
5
0
2 3
/
*
& +
2
#
%
0 /
1
+
.(
6 5
%
2
'
'
( #
,
!
2
0
,
0
-,
(
)
*+
%
( #
!
)
!2
)
4
!"
•
&'
%
$ #
algorytm piekarni
Pi:
W
wybrane[i]:=prawda;
numer[i]:=max(numer[0], numer[1], ..., numer[n-1])+1;
;
for k:=0 to n-1 do
numer[i]:=0;
begin
while wybrane[k] do nic;
while numer[k]<>0 and (numer[k],k)<(numer[i],i) do nic;
end;
Pi:
I
I
I
<
7
5
8
3
@
8 D
<
6 E
=
5
8 ;
nieminimalnych)
<
H<
9
7
<
38
7
6
F
<
?
5 :
7
;
C
@
<
<
9
8
;
5
A 8
3
5
;
8 ;
;
C
3 8
G
7
6D
DA
ten sam numerek !
procesów ? (odp
8
=
D8
5
8
@
9
9
5 :
8 7
C
:B
:
4 3
5
;
B
@
@
9
?
5
8
5
8
3
9
?
B
9
9
5
:
9
5 :
;
C
:B
8 7
5
A:
@
3
4 5
8
3
=
:
?
8 9
A :
=
:
?
8 9
4
4
;
8
–
:
=:
5
:<
9
=:
>
:
5
8
3
<
:
9
87
6
5 :
5
;
43
–
–
?
=
–
7
4
%
2
.
*
/
+ )*
!
#
$
#
"
"
1
(
0 #
- ,
(
' &
•
S
[\
^
]X
^
X
R U
T
_
T
R
ZO
O
R
PYX
T
VWU
SQR
OPMN
KL
numer[i]:=0;
wybrane[i]:=prawda;
numer[i]:=max(numer[0], numer[1], ..., numer[n-1])+1;
;
for k:=0 to n-1 do
krytycznej procesów "mniejszych" od Pi
begin
while wybrane[k] do nic;
while numer[k]<>0 and (numer[k],k)<(numer[i],i) do nic;
end;
J
algorytm piekarni c.d.
Pi:
szy w
sensie specjalnej relacji "<")
znej to
Pi:
!
#
#
&
$
!
#
fun.sys
%
–
"
!
– nie ma w nich aktywnego czekania !!!
fun.sys. lub przez
!
–
•
semafor i monitor
– do synchronizowania procesów
(patrz: wstrzymywanie w problemie prod/kons lub w problemie sek. kryt.)
semafor
–
• def semafora ogólnego
"
!
• wait(s)
je li s>0 to s:=s-1;
je li s=0 to wstrzymaj dzia anie procesu [wywo uj cego wait(s)]
• signal(s)
je li s procesy wstrzymane podczas wait(s) to wznów jeden z nich;
je li nie ma to s:=s+1
• s:=i inicjowanie semafora warto ci "i"
- 7
6
/ 45
3
semafor FIFO/ semafor losowy:
-
(
$+
)
*+,
)
$
(& %
#
8
$
0
&/
-.
0
-
#
#
-
+,
0
(
$
(-
*
2
$1
$
3
;
)
-
0
&/
-.
+
(
+
0
2,
9
:
)
#
*+,
$
( &'%
–
ch na sem."
– FIFO: wznawiamy pierwszy w kolejce proces, a wstrzymywane umieszczamy na jej
FIFO)
– losowy: wznawiamy proces losowo wybrany z kolejki
/ 5
•
•
semafor
przy pomocy semafora ogólnego
– nie ma aktywnego czekania !
– je li to jest semafor FIFO to oprócz wzaj.wykl. i post pu mamy(?) gwarancje
ograniczonego czekania !
#
"
!
until false
#
"
!
wait(s);
sekcja krytyczna
signal(s);
#
"
!
until false
#
"
!
Proces P2:
repeat
wait(s);
sekcja krytyczna
signal(s);
#
"
!
wait(s);
sekcja krytyczna
signal(s);
#
"
!
: s:=1;
Proces P1:
repeat
Proces P0:
repeat
until false
*
)(
&'
$%
+,
(patrz: nast pny slajd ...)
•
semafor
until false
wait(s);
sekcja krytyczna
signal(s);
until false
Proces P2:
repeat
wait(s);
sekcja krytyczna
signal(s);
wait(s);
sekcja krytyczna
signal(s);
: s:=1;
Proces P1:
repeat
Proces P0:
repeat
until false
je li s>0 to s:=s-1;
je li s=0 to wstrzymaj dzia anie procesu [wywo uj cego wait(s)]
signal(s) je li s procesy wstrzymane podczas wait(s) to wznów jeden z nich;
je li nie ma to s:=s+1
s:=i inicjowanie semafora warto ci "i"
wait(s)
semafor
proces
"producent"
2
.
, .
(*
(
1
0 .,
./
.
)
<
9
until false
wait(w);
zapis elementu do bufora
signal(p);
wait(p);
odczyt elementu z bufora
signal(w);
until false
Proces Producent:
repeat
Proces Konsument:
repeat
87
56
34
:;
.
+
, +
) (*
'(
w buforze – trzeba
mamy 2 semafory: w i p
: w:=rozmiar_bufora; p:=0;
&
%
$
#
wstrzymuj
producenta
"!
bufor
proces
"konsument"
gdy bufor pusty
wstrzymuj
konsumenta
• przy pomocy semafora ogólnego ...
•
problem czytelników i pisarzy
– ... istnieje czytelnia oraz dwie kategorie osób: czytelnicy i pisarze;
w danej chwili w czytelni mo e przebywa dowolna liczba czytelników lub
dok adnie jeden pisarz
– (jest to abstrakcja problemu dost pu do bazy danych)
– jak to rozwi za przy pomocy semaforów ogólnych ?
$
!
#
"
!
mamy dwa semafory ogólne R i W;
R:="rozmiar czytelni", W:=1
operacja zajmowania
miejsc w czytelni
%
%
%
&
pisarz wychodzi
for i:=1 to "rozmiar czytelni" do signal(R);
signal(W);
czytelnik wychodzi
signal(R);
pisarz wchodzi
wait(W);
for i:=1 to "rozmiar czytelni" do wait(R);
czytelnik wchodzi
wait(R);
wait(W)/signal(W) ? [zakleszczenie]
problem 5 filozofów
– Pi ciu g odnych filozofów siedzi przy okr g ym
stole, przy talerzach z ryb . Aby je ryb
potrzebne s 2 widelce, jednak mi dzy dwoma
s siednimi filozofami le y tylko 1 widelec.
– Wszyscy filozofowie na przemian my l
i jedz (w niesko czonej p tli).
– Zauwa my e wprowadzenie wzajemnego
wykluczania dla ka dego widelca nie
rozwi zuje problemu: mo e si zdarzy e
wszyscy filozofowie zaczn podnosi widelce
pocz wszy od lewego - wtedy nie bed mogli
podnie prawego widelca - wyst pi tzw
zakleszczenie ...
– jak to rozwi za ?
Odp: ograniczy liczb filozofów równocze nie
próbuj cych je (przy pomocy semafora
ogólnego)
•
%
%
%
-
)
&
%
%
%
)
(
,
-
&
+
(
*
&
)
%
(
'
'
&
'
%
– sem
– sem
!
!
$
#
!
• wait(s)
je li s=1 to s:=0;
je li s=0 to wstrzymaj dzia anie procesu [wywo uj cego wait(s)]
• signal(s)
je li s procesy wstrzymane podczas wait(s) to wznów jeden z nich;
je li nie ma to s:=1
• s:=i inicjowanie semafora warto ci 0 lub 1
"
• signal()
• problemy z semaforami:
–
+
–
–
–
semafor binarny
• def semafora binarnego
•
semafor binarny c.d.
– tylko konsument musi
przy pomocy semafora binarnego
'
/
'
% $
"#
!
.
% '
*-$
+%
%
until false
, !
=
)
% D
?
- .
% D
?
= C
0
= C
1 !
% .
AB
B&
=,
1
G@, !
% .
+-
)
% '
1
?
) :
1B
+
%&$
*)(
until false
, !
/
.
% '
*-$
, !
+%
%
) (
!
"#
Proces Konsument:
);
repeat
wait(S);
{ odczyt elementu z bufora
i jego konsumpcja }
N:=N-1;
signal(S);
);
if N=0 then
'
);
-A
+-
-
-
9
!
'
?@, !
% .
:
?
,B
1
%
9 '
->
,
=*$
<*;
-1
F
&%$
"#
1
2
Proces Producent:
repeat
wait(S);
{ produkuje element
i zapisuje do bufora }
N:=N+1;
if N=1 then
signal(S);
,&0
?
9
%
< E
% :
1
9&
-1
% :
1
9&
+
+
8&7
6&5
4*3
mamy semafory binarne:
y
a
S–
zmienne pomocnicze:
N –zainicjowana 0; jest to liczba nieskonsumowanych elementów w buforze
%
$
•
semafor binarny c.d.
i
)*"
( '
&
"
!
"
N=0; procesor
0
/$
#
$
"!
-!
1.
konsumenta przy pomocy sem. bin.
"
.
" !
%23
"
"
"
/$
,"
.
- !
,
+
(
(
.
+
(
675
8
8
" !
23
5
"
=>
E
B
DC
" G
G
0G
- !
0
<
until false
: !
"
,
+
;
until false
!
$
<
0
: !
"
,
+
;
"
23
F
" !
%23
"
1 $
@A?
8
8
" !
$
"
23
8
,
( '
&
%
:.
- 9
$
$
$
9
4
" !
3
"
$
" !
$
"
23
8
4
" !
3
1$
+
(
"
,"
.
,
+
(
w zaznaczonym punkcie ...
),
2. producent produkuje nowy element przy czym wykonuje
N=1,
3. konsument NIE wykona
) bo N<>0
)
4. konsument konsumuje (ostatni) element z bufora, wykonuje
– ale NIE zostanie wstrzymany bo
!!!
5.
Proces Konsument:
programowanie
Proces Producent:
);
repeat
repeat
semaforów
wait(S);
wait(S);
{ produkuje element
jest trudne ...
{ odczyt elementu z bufora
i zapisuje do bufora }
i jego konsumpcja }
N:=N+1;
N:=N-1;
);
if N=1 then
signal(S);
signal(S);
);
if N=0 then
procedurach monitora
- sekcje krytyczne
#
C
E
@
A
B
? >
$
=
<;
:
– W danej chwili tylko jeden
C
$
# D
#$
9
# 8
# 7
–
.
+,
23
6
5
4
-
(
0
1
/0
-
'(
&
monitor semaforX
var x: integer; c:condition;
procedure waitX();
begin
if x=0 then waitc(c) else x:=x-1;
end;
procedure signalX();
begin
if empty(c) then x:=x+1 else signalc(c);
end;
end;
)*
%
warunki:
BACI }
#$
"
–
•
!
•
monitory
def monitora:
.
w monitorze (tj
tora),
<0
=
=
1
-
8
9
/
5
=
4
-
=
=
8
5
;
2
8
>
=
=
/
=
0
5
;
-
;
-
<0
1
-
89
5
89
1
:
/
7
proces zostanie wstrzymany i umieszczony
/
5 6
;
56
ten inny
kolejki procesów
jest
4
-.
/
/
/
2
3
/
,
* )
( &
•
– Gdy monitor jest
'(
/
1
/
0
/
-.
+,
)
/
!
*'
&
$
&
$%#
"
!
•
wstrzymywania i wznawiania
monitora przy pomocy zmiennych typu condition
waitc()" oraz "signalc()".
– Po wykonaniu waitc(c) gdzie "c" jest zmienna typu conditon proces jest
or jest
zwalniany
– Po wykonaniu signalc(c) budzony jest jeden z procesów wybrany losowo z
signalc()" jest usypiany i
umieszczany
–
sta przy
pomocy "empty(c)".
–
/
–
•
monitory c.d.
def monitora c.d:
monitora)
conditon.
monitory c.d.
monitory c.d.
•
przy pomocy monitorów:
Kons,Prod:condition;
{kolejki wstrzymanych konsumentów i producentów}
procedure WstawElement(el:integer); {PRODUCENT}
begin
if W=0 then waitc(Prod);
{wstaw "el" do bufora} W:=W-1; P:=P+1;
signalc(Kons);
end;
procedure OdczytajElement(var el:integer); {KONSUMENT}
begin
if P=0 then waitc(Kons);
{odczytaj element "el" z bufora} W:=W+1; P:=P-1;
signalc(Prod);
end; end;
1
/
*0
(
-.,
"
( +
&
%
*
%
&
()'
$
#
"
!
monitor ProdKons;
var {deklaracje bufora i jego indeksów ...}
P,W:integer;
prod & kons):
+
)(
$
%
*
)
'&%
(
!"
!#
$"
– Linux
Java, monitor01.java
–
•
monitory c.d.
pthread", monitor01.cc