Ejercicios de Concurrencia y Sincronización del libro Sistemas

Operativos de William Stallings

1.- Considere un programa concurrente con dos procesos P y Q, definidos a continuación.
A, B, C, D y E son sentencias arbitrarias atómicas (indivisibles). Supóngase que el
programa principal (no mostrado) ejecuta concurrentemente los procesos P y Q

P() Q()
{ {
A; D;
B; E;
C; }
}

Indicar todas las posibles intercalaciones de los dos procesos anteriores (indicarlo por
medio de trazas de ejecución dadas en términos de sentencias atómicas).

2.- Considere la siguiente función llamada por un pthread_create donde dos hilos
incrementan una variable global.

int cuenta;
void total()
{
int i;
for(i=0;i<1000;i++)
cuenta++;
}

1. Determinar los valores mínimos y máximos que puede tomar la variable cuenta.
Suponga que incrementar una variable en memoria requiere 3 operaciones
a. Carga la variable en un registro
b. Incrementa el registro
c. Carga el registro en la variable
2. Supóngase que se permite ejecutar un número arbitrario de procesos bajo el
apartado (a), ¿qué efecto tendría esa modificación

3.- Considere el siguiente programa

int bloqueado[2];
int turno;
void P(int id)
{
while(cierto)
{
bloqueado[id]=cierto;
1
 while(turno!=id)
{
while(bloqueado[1-id])
{
turno=id;
}
}
/* Sección crítica */
bloqueado[id]=falso;
/* Resto */
}
}

Busque un contraejemplo que muestre que esta solución propuesta es incorrecta.

4.- El código que se muestra en la Figura 1 es el intento donde dos procesos P(0) y P(1)
se sincronizan a través de un algoritmo por software empleando variables en memoria
compartida.

Haga un análisis de la ejecución concurrente de los dos procesos en una tabla donde se
muestra la ejecución intercalada de instrucciones de ambos procesos, y muestre si esta
solución funciona o no funciona, en caso de no funcionar explique el por qué.

boolean flag[2];
int turno=0;

P(i)
{
j=1-i;
while(forever)
{
turno=j;
while(flag[j] && turno!=i){};
flag[i]:=true;
CS
flag[i]:=false;
RS
}
}
Figura 1. Código que ejecutan P(0) y P(1)

5.- Compara las definiciones de semáforos enteros donde los semáforos enteros pueden
tomar valores negativos y aquellos donde no toman valores negativos, ¿hay alguna
diferencia en el efecto de las dos definiciones cuando se utilizan para sincronizar

2
procesos? Es decir, ¿es posible sustituir una definición por la otra sin alterar el
significado del programa?

6.- Probar la corrección del algoritmo de Dekker y que se respeta la exclusión mutua.
Pista: demostrar que cuando Pi entra en su sección crítica es cierta la siguiente expresión:

señal[i] and (not señal[1-i])

Probar que un proceso que solicita acceso a su sección crítica no será retrasado
indefinidamente. Pista: considérense los siguientes casos: (1) un único proceso
intenta entrar en la sección crítica y (2a) turno=0 y señal[0]=falso y (2b)
turno=0 y señal[0]=cierto.

7.- Considere el algoritmo de Dekker para un número arbitrario de procesos, cambiando

la sentencia ejecutada cuando se abandona la sección crítica de:

turno=1-i
turno=(turno+1)%n /*n es el número de procesos*/

Evaluar el algoritmo cuando el número de procesos que se ejecutan concurrentemente es

mayor de dos.

8.- Considere el ejemplo del productor consumidor que se muestra a continuación

Program buffer_limitado;
const tamaño_buffer=...;
var s:semáforo(:=1);
n:semáforo(:=0);
e:semáforo(:=Tamaño_buffer);

procedure productor;
begin
repeat
producir;
wait(e);
wait(s);
añadir;
signal(s);
signal(n);
forever
end;
procedure consumidor;
begin
repeat

3
 wait(n);
wait(s);
tomar;
signal(s);
signal(e);
consumir;
forever
end;
begin
parbegin
productor;consumidor
parend
end.

9.- ¿Cambiaría el significado del programa si se intercambian las siguientes sentencias?

1. wait(e); wait(s)
2. signal(s); signal(n)
3. wait(n); wait(s)
4. signal(s); signal(e)

10.- Basándose en la experiencia obtenida en el desarrollo de las prácticas donde

sincronizamos hilos con semáforos y paso de mensajes.

a) Si tengo un hilo productor y dos consumidores, indique empleando pseudocódigo

como se realiza esa sincronización con semáforos.

b) En el mismo caso de un hilo productor y dos consumidores, indique empleando

pseudocódigo como se realiza la sincronización y comunicación empleando un
sistema de paso de mensajes.

c) ¿Cuáles son las ventajas y desventajas de hacer la sincronización y comunicación

con semáforos o con paso de mensajes?, mencione al menos dos ventajas y dos
desventajas de los semáforos y dos ventajas y dos desventajas de hacerlo a través
de paso de mensajes.

11.- De ser posible implementar semáforos generales por medio de semáforos binarios.
Se pueden usar las operaciones WaitB y SignalB y dos semáforos binarios espera y
exmut. Considere lo siguiente:

Typedef struct {
int Contador;
BinSemaphore espera=0;
} semáforo

BinSemaphore exmut=1;

4
void Wait(semáforo s)
{
WaitB(exmut);
s.contador--;
if(s.contador!=0)
{
SignalB(exmut);
WaitB(s.espera);
}
else
Signal(exmut);
}

void Signal(semáforo s)
{
Waitb(exmut);
s.contador++;
If(s.contador!=0)
SignalB(s.espera);
SinalB(exmut);
}

Inicialmente, s.contador tiene el valor deseado por el semáforo. Cada operación

Wait disminuye s.contador y cada operación Signal lo incrementa. El semáforo
binario exmut iniciado en 1, asegura que hay exclusión mutua en las actualizaciones de
s.contador. El semáforo binario s.espera, iniciado a 0, se usa para suspender
procesos.

De acuerdo a las especificaciones anteriores, muestren si la implementación de semáforos

enteros a partir de semáforos binarios es correcta, y si no lo es indique en dónde es
incorrecto, proponga la corrección.

12.- La siguiente solución intenta resolver el problema de permitir que K de n procesos

puedan ejecutar concurrentemente su sección crítica usando para esto sólo semáforos
binarios.

Muestre si es posible que haya más de K procesos en la sección crítica para:

k=2 n=3
k=2 n=4

y se podría concluir que no funciona para valores de n mayores

Muestre que problemas puede presentar esta solución.

Plantee una solución que resuelva correctamente con semáforos binarios dicho problema.

5
 // Constantes
const int K=2;
const int N=4;

// Variables
int contador;
int bloqueados=0;
binarysem mutex=1;
binarysem retardo=0;

void proceso()
{

1: wait(mutex);
2: if(contador==0)
{
3: bloquados++;
4: wait(retardo);
}
else
5: contador--;
6: signal(mutex);

// Sección crítica

7: wait(mutex);
8: if(bloqueados>0)
{
9: signal(retardo);
10: bloqueados--;
}
11: else
12: contador++;
13: signal(mutex);
}

void main()
{
14: contador=K;
cobegin
{
15: proceso(); proceso(); proceso();proceso();
}
}

6
13.- En el caso del problema del productor consumidor que se muestra en la Figura 2, la
sincronización se hace con un monitor con notificación definido a partir de semáforos.
Para esto fue necesario implantar las funciones:

 entrar_monitor(): Permite que solo un proceso/hilo entre a esa sección ya

considerada como parte del monitor.
 cwait(): Bloquea un proceso/hilo dentro del monitor.
 cnotify(): Desbloquea todos los procesos/hilos que están bloqueados en la
zona de espera del monitor.
 leave_monitor(): Permite que otro proceso/hilo entre al monitor.

El problema es que la librería donde se definen esta funciones se extravió, por lo que es
necesario re-definirlas.

Defina utilizando pseudocódigo los semáforos necesarios y estas cuatro funciones para
que a partir de semáforos, agrega_al_buffer() y tomar_del_buffer() se
comporten como procedimientos de un monitor.

int agrega_al_buffer(e)
{
enter_monitor();

while(elementos==MAX_CAPACIDAD)
cwait();
ent++;
end=ent%MAX_CAPACIDAD;
buffer[ent]=e;
elementos++;

cnotify();
leave_monitor();
}

int tomar_del_buffer()
{
enter_monitor();
while(elementos==0)
cwait();
sal++;
sal=sal%MAX_CAPACIDAD;
e=buffer[sal];
elementos-- ;

cnotify();
leave_monitor();

7
 return(e);
}

int Productor()
{
int e;
while(forever)
{
e=Produce_elemento();
agrega_al_buffer(e);
}
}

int Consumidor()
{
int e;
while(forever)
{
e=tomar_del_buffer();
consumir(e);
}
}
Figura 2.- Ejemplo del productor consumidor con monitores.

14.- A partir de semáforos implementar una estructura equivalente a monitores con

señales

15.- A partir de semáforos implementar una estructura equivalente a monitores con

notificación.

16.- En cuanto al problema de la barbería equitativa vista en clase

 ¿Requiere el código que cobre el pago de un corte de pelo a un cliente el mismo
barbero que lo terminó?
 ¿Usan los barberos la misma silla?

17.- Un sistema operativo carece de un sistema de paso de mensajes por lo cual no

existen las primitivas send y receive. Para ciertos problemas es conveniente plantear
la solución considerando que el sistema de paso de mensajes si existe donde tenemos la
primitiva send no bloqueante y la primitiva receive bloquente.

Utilizando semáforos enteros y otro mecanismo de comunicación entre procesos,

implemente un sistema de paso de mensajes. Defina empleando pseudocódigo las
primitivas send y receive para paso de mensajes.

8
18.- El parque jurásico está formado por un museo de dinosaurios y un parque para
excursionistas de safari. Hay m pasajeros y n coches monoplaza. Los pasajeros dan
vueltas por el museo durante un tiempo y después se ponen en fila para dar un paseo en
un coche de safari. Cuando el coche está disponible, carga un pasajero, carga un pasajero
y recorre el parque durante un tiempo aleatorio. Si los n coches están todos dando vueltas
a los pasajeros, los que quieren subir deben esperar; si un coche está listo para recoger
pasajeros, pero no hay ninguno esperando, el coche debe esperar. Use semáforos para
sincronizar los procesos de los m pasajeros con los m coches.

El siguiente código se encontró en un pedazo de papel suelto en la sala de exámenes.

Determinar si es correcto o no lo es.

Semaphore coche_vacio=0;
Semaphore tomar_coche=0;
Semaphore coche_lleno=0;
Semaphore pasaje_libre=0;

Pasajero()
{
while(forever)
{
sleep(tiempo_aleatorio);
wait(coche_vacio);
signal(tomar_coche);
wait(coche_lleno);
wait(pasaje_libre);
}
}

Coche()
{
while(forever)
{
signal(coche_vacio);
wait(tomar_coche);
signal(coche_lleno);
sleep(tiempo_aleatorio);
signal(pasaje_libre);
}
}

main()
{
int i;
cobegin
{
for(i=0;i<M;i++) Pasajero();

9
 for(i=0;i<N;i++) Coche();
}
}

19.- Demostrar que el paso de mensajes y los semáforos tienen una funcionalidad
equivalente:
 Implementando el paso de mensajes por medio de semáforos. Pista: haga uso de
un área de elementos compartidos para contener buzones, cada uno de ellos
formado por un arreglo de espacios para este mensaje.
 Implementando un semáforo por medio del paso de mensajes. Pista: cree un
proceso independiente para la sincronización.

20.- El ejemplo que se muestra en la Figura 3 es el programa que calcula la serie de

Mercator ya paralelizado utilizando los hilos de la API de WIN32. Este fue paralelizado
por un programador “de Lucita te Capacita”, en este caso el programador utilizó técnicas
de programación que no son las adecuadas para tener el rendimiento deseado de la
aplicación, por lo que te contrataron a ti como Ingeniero en Sistemas Computacionales
del ITESO para que lo optimices.

/*
This simple code demonstrates CreateEvent, WaitForMultipleObjects
Win32 API functions and event objects.

This code computes sum of Mercator's series.

Mercator's series expression for ln( x + 1 ) function is:

ln( x + 1 ) = x - x^2/2 + x^3/3 - x^4/4 + x^5/5 - ...

for -1 < x <= 1.

*/

#include <stdio.h>
#include <conio.h>
#include <time.h>
#include <windows.h>
#include <math.h>

#define NUMTHREADS 4
#define SERIES_MEMBER_COUNT 20000

HANDLE *threadHandles, masterThreadHandle;

CRITICAL_SECTION countCS;
double *sums;
double x = 1.0, res = 0.0;
int threadCount = 0;
int startall = 0;

double getMember(int n, double x)

{
double numerator = 1;

10
 for( int i=0; i<n; i++ )
numerator = numerator*x;

if ( n % 2 == 0 )
return ( - numerator / n );
else
return numerator/n;
}

DWORD WINAPI threadProc(LPVOID par)

{

int threadIndex = *((int *)par);

while(!startall);

sums[threadIndex] = 0;
for(int i=threadIndex; i<SERIES_MEMBER_COUNT;i+=NUMTHREADS)
sums[threadIndex] += getMember(i+1, x);

//Signal Master thread that one more processing thread is done

EnterCriticalSection(&countCS);
threadCount++;
LeaveCriticalSection(&countCS);

delete par;
return 0;
}

DWORD WINAPI masterThreadProc(LPVOID par)

{
Sleep(1000);
startall=1;

while (threadCount != NUMTHREADS) {} // busy wait until all

threads are done with computation of partial sums
res = 0;

for(int i=0; i<NUMTHREADS; i++)

res += sums[i];
return 0;
}

void main()
{
threadHandles = new HANDLE[NUMTHREADS + 1];
InitializeCriticalSection(&countCS);
sums = new double[NUMTHREADS];
clock_t start,stop;

start=clock();
for(int i=0; i<NUMTHREADS;i++)
{
int * threadIdPtr = new int;
*threadIdPtr = i;
threadHandles[i] = CreateThread(NULL, 0, threadProc,
threadIdPtr, 0, NULL);

11
 }
threadHandles[NUMTHREADS] = CreateThread(NULL, 0,
masterThreadProc, NULL, 0, NULL);

printf("Count of ln(1 + x) Mercator's series members is

%d\n",SERIES_MEMBER_COUNT);
printf("Argument value of x is %f\n", (double)x);

WaitForMultipleObjects(NUMTHREADS+1,threadHandles,TRUE,INFINITE);
stop=clock();

printf("Tiempo = %2.7f\n",(float)(stop - start)/ CLOCKS_PER_SEC);

for(int i=0; i<NUMTHREADS+1; i++ ) CloseHandle(threadHandles[i]);

delete threadHandles;
DeleteCriticalSection(&countCS);
delete sums;

printf("Result is %10.8f\n", res);

printf("By function call ln(1 + %f) = %10.8f\n",x, log(1+x));
printf("Press any key ... ");
_getch();
}
Figura 3.- Programa de la serie Mercator

a) Indica cuáles son las técnicas de programación no adecuadas, y porque no son

adecuadas
b) Utilizando semáforos, haz que esta solución sea eficiente.
c) Utilizando un sistema de paso de mensajes haz que esta solución sea eficiente, es
necesario que indiques el comportamiento de las primitivas Send y Receive.

Interbloqueo
1.- Defina el bloqueo mutuo.

2.- De un ejemplo de bloqueo mutuo en el que participe solamente un proceso, ¿Es

posible eso?, explique su respuesta

3.- Cite tres ejemplos de bloqueos mutuos no relacionados con un entorno de sistema de
computación.

4.- Proporcione un ejemplo sencillo de bloqueo mutuo de recursos en el que participen

tres procesos y tres recursos. Dibuje la gráfica apropiada apropiada de asignación de
recursos.

5.- Considere el ejemplo de bloqueo mutuo de tráfico (ver las diapositivas de la

presentación de Power Point usada en la clase para el tema de “Interbloqueo”)

12
 1. Demuestre que las cuatro condiciones necesarias para el bloqueo mutuo se
cumplen en este ejemplo.
2. plantee una regla sencilla que evite los bloqueos mutuos en tal sistema

6.- Resuelva el problema de la cena de los filósofos por medio de monitores en vez de
semáforos.

7.- El garage llamado “Arregla tu Casa” presta herramientas a trabajadores que requieren
hacer reparaciones a su casa.

El garage tiene en su inventario:

Martillos Escaleras Taladros

9 3 6

4 trabajadores llamados Alberto, Juan, Pepe y Toño solicitarán herramientas al Garage

quien les prestará las herramientas, pero ellos las devolverán solo hasta que hayan
terminado de hacer todas las reparaciones a sus casas.

Para hacer todas las reparaciones a sus casas los trabajadores necesitarán tener en un
momento dado todas las herramientas que se listan a continuación:

Martillos Escaleras Taladros

Alberto 3 2 2
Juan 6 1 3
Pepe 3 1 4
Toño 4 2 2

Los trabajadores van haciendo sus solicitudes conformen inician las obras y van
requiriendo la herramienta, en una primera solicitud de herramientas solicitan lo
siguiente:

Martillos Escaleras Taladros

Alberto 1 0 0
Juan 5 1 1
Pepe 2 1 1
Toño 0 0 2

De esta manera queda disponible en el garage el siguiente inventario

Martillos Escaleras Taladros

1 1 2

13
a).- Haz una tabla que muestre cuantas herramientas les hace falta a cada uno de los
trabajadores para terminar sus respectivos trabajos.

b).- Supón que una hora más tarde Alberto llega al garage y hace una segunda solicitud:

Martillos Escaleras Taladros

Alberto 1 0 1

¿Es posible conceder el préstamo y que el garage siga teniendo las herramientas
disponibles para seguir prestando y asegurar que al menos uno de los trabajadores va a
terminar su trabajo y va a devolver las herramientas?

c).- Supón que en vez de ser Alberto el que llega una hora más tarde es Juan y hace una
segunda solicitud:

Martillos Escaleras Taladros

Juan 1 0 1

¿Es posible conceder el préstamo y que el garage siga teniendo las herramientas
disponibles para seguir prestando y asegurar que al menos uno de los trabajadores va a
terminar su trabajo y va a devolver las herramientas?

d).- ¿Es posible que haya un algoritmo que le permite al administrador del Garage saber
si debe conceder una solicitud?, si es así, diseña un algoritmo.

14