UNIVERSIDAD NACIONAL JORGE BASADRE GROHMANN

FACULTAD DE INGENIERA
ESCUELA ACADMICO PROFESIONAL DE INGENIERA EN INFORMTICA Y SISTEMAS

PRACTICA N06:LECTORES-ESCRITORES
CURSO: Algoritmos y programacin paralela
CDIGO UNIVERSITARIO: 2015-119013
AO: Segundo SECCIN: Maana GRUPO: Porfirio Chata Ramrez
FECHA DE ELABORACIN: 14/10/16
FECHA DE ENTREGA DEL INFORME: 26/10/16

TACNA-PER
2016

NDICE
I.

OBJETIVOS:...............................................................................................................1

II. FUNDAMENTO TERICO.......................................................................................1

i. PROBLEMAS DEL PRODUCTOR CONSUMIDOR...1

ii. ALGORITMO DE LA BARRERA...2

iii. LECTORES ESCRITORES.3
III.

PROCEDIMIENTO Y DESARROLLO..................................................................3
i. ALGORITMO DE LA BARRERA3

ii. PROBLEMA DEL PRODUCTOR-CONSUMIDOR....5

iii. EJERCICIO PROPUESTO 17
iv. EJERCICIO PROPUESTO 2...8.
IV.

CONCLUSIONES..........................................................................................10

V. REFERENCIA BIBLIOGRFICA...........................................................................10

I.

OBJETIVOS:

II.
i.

Analizar cmo se soluciona el problema de los lectores escritores usando semforos.

Analizar las diferentes versiones de la solucin al problema de los lectores escritores.
Resolver los problemas propuestos usando semforos.
Analizar cmo se soluciona el algoritmo de la barrera usando semforos.
Analizar cmo se soluciona el problema del productor consumidor usando semforos.

FUNDAMENTO TERICO
PROBLEMAS DEL PRODUCTOR CONSUMIDOR

Para explicar el concepto de procesos cooperativos, consideremos el ejemplo

del productor/consumidor. En nuestro caso, un proceso productor genera
informacin que consume un proceso consumidor. Generalmente, pensamos
en un servidor como un productor y en un cliente como un consumidor. Por
ejemplo, un servidor Web proporciona los archivos e imgenes que lee el
explorador de Internet cliente que solicita el recurso. Una buena solucin para
el problema del productor/ consumidor es utilizar los mecanismos de la
memoria compartida. Para permitir que los procesos (productor y consumidor)
se ejecuten de forma concurrente, debemos disponer de un bfer de elementos
que pueda llenar el proceso productor y acceder el proceso consumidor. Este
bfer se encontrar en una regin de memoria que compartirn ambos
procesos, el consumidor y el productor. El productor y el consumidor deben
estar sincronizados, para que el consumidor no intente acceder a un elemento
que todava no se haya creado. Pueden emplearse dos tipos de bferes. El
modo de bfer no limitado no pone lmites al tamao de la memoria

compartida. El proceso consumidor puede tener que esperar para poder

acceder a elementos nuevos, pero el proceso productor siempre puede generar
nuevos elementos. El modo de bfer limitado establece un tamao fijo de
bfer. En este caso, el proceso consumidor tiene que esperar si el bfer se
encuentra vaco y el proceso productor tiene que esperar si el bfer est
totalmente lleno.(Rodriguez Luis Duran,2007).
ii.

ALGORITMO DE LA BARRERA
Es un mecanismo de sincronizacin que obliga a procesos concurrentes (o
distribuidos) a esperar a que todos hayan llegado a un punto determinado.
Solo podrn continuar cuando todos los procesos hayan llegado a una barrera.
El conjunto de los puntos de sincronizacin se denomina barrera.
Barreras binarias
Una barrera binaria es una extensin del ejemplo anterior, donde solo uno de
los procesos deba esperar por el otro. En cambio, una barrera hace que ambos
deban esperar a que el otro acabe una fase para avanzar a la siguiente; adems,
las barreras pueden usarse cclicamente.
El algoritmo de barreras para dos procesos es trivial, hacen falta dos
semforos binarios inicializados a cero. El valor de cada semforo indica si su
proceso correspondiente lleg a la meta. Cada proceso ejecuta signal en su
semforo para indicar que lleg al final de una fase, y luego wait en el
semforo del otro proceso.(Ricardo Galli,2015)

iii.

LECTORES ESCRITORES

En aplicaciones reales, la mayora de las operaciones sobre la memoria son

lecturas. En estos casos lo importante es que estas sean consistentes. En los
ejemplos un nico contador entero no existe el problema de lectura
inconsistente: las palabras de 32 bits son registros atomicos en las
arquitecturas modernas de 32 o ms bits, si un proceso Ice la variable siempre
obtendr el ltimo valor escrito. Para estructuras de mayor tamao o para
acceder a ficheros o dispositivos externos hay que imponer restricciones
para que la memoria no sea modicada cuando otros procesos la estn
leyendo.
La solucin de exclusin mutua no es la ms adecuada, la sealizacin de los
accesos de solo lectura provoca esperas innecesarias Una de las relajaciones
ms importantes a las condiciones de la exclusin mutua es que se permita
ms de un lector en la seccin crtica. Estos algoritmos son conocidos como
lectoresescritores(Ricardo Galli,2015)

III. PROCEDIMIENTO Y DESARROLLO

i.

ALGORITMO DE LA BARRERA

Permite que varios procesos no se ejecuten a la vez con ayuda de las operaciones
de los semforos donde tendrn que esperar al ultimo proceso para salir de la
espera limitada.

TABLA 1
Cdigo en PascalFC usando semforos para el algoritmo de la barrera.
program BARRERA;
const
N=10;
var
barrera,mutex :semaphore;
i, nprocesos,j:integer;
process type b(i:integer);
begin
wait(mutex);
nprocesos :=nprocesos+1;
if nprocesos<N then
begin
signal(mutex);
writeln('Proceso: ',nprocesos,' en espera');
wait(barrera);
end
else
begin
writeln('Llegada del ultimo proceso: ',N);
for j:=1 to n-1 do
begin
signal(barrera);
writeln('Salida del proceso: ',j);
end;
nprocesos:=0;
signal(mutex);
end;
end;

var
p:array[1..N]of b;
begin
nprocesos:=0;
initial(barrera,0);
initial(mutex,1);
cobegin
for i:=1 to N do
begin
p[i](i);
end;
coend;
end.

Figura 1.Salida del programa tras haber ejecutado el cdigo de la Tabla 1.

ii.

PROBLEMA DEL PRODUCTOR-CONSUMIDOR

Se trata de un proceso que produce elementos y otro que los consume por lo que
debern respetar la exclusin mutua y las condiciones de sincronizacin, para

ello usaremos los semforos que nos permitirn usar la variable compartida de
manera correcta.
TABLA 2
Cdigo en PascalFC usando semforos para el problema del productorconsumido.
program consumidorproductor;
const
N=5;
var
vacios,mutex,llenos :semaphore;
final,elemento,frente:integer;
cola :array[0..N]of integer;
process producir;
begin
repeat
elemento:=random(49)+1;
writeln('PRODUCIR ELEMENTO: ',elemento);
wait(vacios);
wait(mutex);
cola[final]:=elemento;
final:=(final+1)mod N;
signal(mutex);
signal(llenos);
forever
end;
process consumir;
begin
repeat
wait(llenos);
wait(mutex);
elemento:=cola[frente];
frente:=(frente+1)mod N;
signal(mutex);
signal(vacios);
writeln('CONSUMIR ELEMENTO: ',elemento);
forever
end;

begin
final:=0;
frente:=0;
initial(vacios,N);
initial(llenos,0);
initial(mutex,1);
cobegin
producir;
consumir;
coend;
end.

Figura 2.Salida del programa tras haber ejecutado el cdigo de la Tabla 2.

iii.

EJERCICIO PROPUESTO 1
Aada un semforo al siguiente programa para que siempre imprima 40.
7

TABLA 3
Cdigo en PascalFC del ejercicio propuesto 1.
program ejercicio1;
var
x,i: integer;
var
s:semaphore;
process inc;
begin
wait(s);
for i:=1 to 20 do
begin
x:=x+1;
end;
signal(s);
end;
process ind;
begin
wait(s);
for i:=1 to 20 do
begin
x:=x+1;
end;
signal(s);
end;
begin
initial(s,1);
x:=0;
cobegin
inc;
ind;
coend;
writeln(x);
end.

Figura 3.Salida del programa tras haber ejecutado el cdigo de la Tabla 3.

iv.

EJERCICIO PROPUESTO 2
Se desea realizar una competencia de N jugadores la competencia iniciara
cuando se renan los N jugadores .Modele el problema con semforos.

TABLA 4
Cdigo en PascalFC del ejercicio propuesto 2.
program JUGADOR;
const
N=11;
var
barrera,mutex :semaphore;
i, njugadoes,j:integer;
process type b(i:integer);
begin

wait(mutex);
njugadoes :=njugadoes+1;
if njugadoes<N then
begin
signal(mutex);
writeln('Jugador: ',njugadoes,' en espera');
wait(barrera);
end
else
begin
writeln('Llegada del ultimo JugadoR: ',N);
for j:=1 to n-1 do
begin
signal(barrera);
writeln('Salida del Jugador: ',j);
end;
njugadoes:=0;
signal(mutex);
end;
end;
var
p:array[1..N]of b;
begin
njugadoes:=0;
initial(barrera,0);
initial(mutex,1);
cobegin
for i:=1 to N do
begin
p[i](i);
end;
coend;
end.

10

Figura 4.Salida del programa tras haber ejecutado el cdigo de la Tabla 4.

IV. CONCLUSIONES

Se solucion los problemas de productor consumidor usando semforo.

Se solucion el algoritmo de la barrera usando semforos.

Se resolvieron los problemas propuestos

V. REFERENCIA BIBLIOGRFICA
Galli Granada Ricardo(2015). Principios y algoritmos de concurrencia.(Primera
Edicin)JRMora.
Duran Rodriguez Luis.El gran libro del PC interno.(Primera Edicin)Espaa:
Editorial Marcombo

11