Practica Algoritmos paralelos

Realice un programa concurrente con uso de sincronizacin variable compartida

(algoritmo de Dekker o Peterson), que simula la actividad del banco, en la cual las dos
operaciones son realizadas por procesos diferentes. Suponga que el proceso se repite
infinitamente. El programa concurrente se debe realizar en PascalFC.

Planteamiento del problema

El Banco.
Supongamos un banco que tiene 20 cuentas, numeradas del 1 al 20, y cada cuenta tiene,
inicialmente, S/. 100 de saldo. Por lo tanto, el banco tiene S/. 2 000. El banco realiza
dos operaciones:

1. Contabiliza los saldos de todas las cuentas (cada minuto).

2. Traspasos de una cuenta a otra (cuentas elegidas aleatoriamente y el saldo aleatorio
entre 0 y 10).

ACTIVIDADES
1. Aplicar uno a uno los intentos de exclusion mutua y sincronizacion indicados en
la teora.
2. Analizar las dos soluciones propuestas a continuacin.
Solucin 1:

Aplicaremos el Algoritmo de Peterson con sincronizacin y exclusin mutua:

PROGRAM problema5;
CONST NCTAS=20; c1:=RANDOM(NCTAS-1)+1;
kRunTime = 120; c2:=RANDOM(NCTAS-1)+1;
kSleepTime = 10; Writeln('Cuentas Aleatorias',c1,' y',c2);
cant:=0;
VAR Cuenta:array[1..NCTAS] of integer; IF(Cuenta[c1]>10) THEN cant:=RANDOM(10);
i: Integer; Cuenta[c1]:=Cuenta[c1] - cant;
finished : boolean; Writeln('Nuevo Monto para Cuenta',c1,' es:',Cuenta[c1]);
flag1 : boolean; Cuenta[c2]:=Cuenta[c2] - cant;
flag2 : boolean; Writeln('Nuevo Monto para Cuenta',c2,' es:',Cuenta[c2]);
turn : integer; flag2 := false;

end;
PROCESS ContarSaldos; END;
VAR ci, Total: INTEGER;
BEGIN
while not finished do PROCESS AUDITOR;
begin begin
flag1 := true; while not finished do
turn := 2; begin
while (flag2 and (turn = 2)) do sleep(random(kSleepTime));
begin writeln('Un Momento...');
null; end;
end; end;

Total:=0;
FOR ci:=1 TO NCTAS DO process supervisor;
Total:=Total + Cuenta[ci]; begin
Writeln('Total del Banco:',Total); sleep(kRunTime);
finished := true;
flag1 := false; end;

end;
(*MAIN*)
END; BEGIN
(*INICIAMOS LOS MONTOS DE 100 SOLES PARA
CADA CUENTA*)
For i:=1 TO NCTAS DO Cuenta[i]:=100;
finished := false;
PROCESS Operacion; flag1 := false;
VAR c1, c2, cant: Integer; flag2 := false;
BEGIN turn := 1;
while not finished do
begin (*EMPEZAMOS LOS PROCESOS*)
flag2 := true; COBEGIN
turn := 1; supervisor;
while (flag1 and (turn = 1)) do auditor;
begin Operacion;
null; ContarSaldos;
end;
COEND
sleep(1); END.
 En cdigo mostrado, se toman en cuenta dos operaciones: Operacin que son la
operacin que se realiza entre dos cuenta aleatorias y ContarSaldos que es la
cuenta recursiva cada minuto del proceso de saldo del banco. Le proceso de
supervisor y auditor son patrones tomados del algoritmo de Peterson.

Se muestra a continuacin los resultados del programa:

- Interpreter Version P5.3 -

Program banco ... execution begins ...

Cuentas Aleatorias 5y 10
Nuevo Monto para Cuenta 5 es: 95
Nuevo Monto para Cuenta 10 es: 95
Total del Banco: 1990
Cuentas Aleatorias 3y 5
Nuevo Monto para Cuenta 3 es: 99
Nuevo Monto para Cuenta 5 es: 94
Total del Banco: 1988
Cuentas Aleatorias 8y 14
Nuevo Monto para Cuenta 8 es: 90
Nuevo Monto para Cuenta 14 es: 90

Solucin 2:
Otro aplicando otro algoritmo de exclusin mutua de Dekker:

PROGRAM banco;
CONST NCTAS=20;
VAR Cuenta:array[1..NCTAS] of integer;
i: Integer;
finished : boolean;
flag1 : boolean;
flag2 : boolean;

PROCESS ContarSaldos;
VAR ci, Total: INTEGER;
BEGIN
while not finished do
begin
sleep(1);
while flag1 do
begin
null;
end;
flag2 := true;

Total:=0;
FOR ci:=1 TO NCTAS DO
Total:=Total + Cuenta[ci];
Writeln('Total del Banco:',Total);
flag2 := false;

end;

END;
PROCESS Operacion;
VAR c1, c2, cant: Integer;
BEGIN
while not finished do
begin

while flag2 do
begin
null;
end;
(* flag1 := true; *)

c1:=RANDOM(NCTAS-1)+1;
c2:=RANDOM(NCTAS-1)+1;
Writeln('Cuentas Aleatorias',c1,' y',c2);
cant:=0;
IF(Cuenta[c1]>10) THEN cant:=RANDOM(10);
Cuenta[c1]:=Cuenta[c1] - cant;
Writeln('Nuevo Monto para Cuenta',c1,' es:',Cuenta[c1]);
Cuenta[c2]:=Cuenta[c2] + cant;
Writeln('Nuevo Monto para Cuenta',c2,' es:',Cuenta[c2]);

(* flag1 := false; *)

end;
END;

(*MAIN*)
BEGIN
(*INICIAMOS LOS MONTOS DE 100 SOLES PARA CADA CUENTA*)
For i:=1 TO NCTAS DO Cuenta[i]:=100;
finished := false;
flag1 := false;
flag2 := false;

(*EMPEZAMOS LOS PROCESOS*)

COBEGIN
Operacion;
ContarSaldos;

COEND
END.