Está en la página 1de 11

Práctico Procesos

Procesos e Hilos

1. ¿Por que un hilo dejaría voluntariamente la CPU con un thread_yield si sabe que después de esto puede que se quede sin CPU para siempre?

La realidad es que nuestro ordenador, salvo que tenga varias cpu, no ejecutará varias cosas a la vez. Cuando digo "a la vez", me refiero a que el sistema operativo irá ejecutando cachos de programa por turnos (por rodajas de tiempo) de forma muy rápida, dando la sensación de simultaneidad

2. En un sistema con hilos, ¿hay un solo stack por hilo o un stack por proceso cuando se usan hilos en espacio de usuario? En realidad dentro de la memoria hay varios stacks, en general cada programa tiene el suyo¿Y si se usan hilos a nivel de kernel? El intercambio de los hilos no necesita los privilegios del modo kernel, por que todas las estructuras de datos están en el espacio de direcciones de usuario de un mismo proceso. Por lo tanto, el proceso no debe cambiar a modo kernel para gestionar hilos. Se evita la sobrecarga de cambio de modo y con esto el sobrecoste.

3. Para el siguiente programa decidir que valores se pueden imprimir.

int a, *ptr_b;

a = 0;

ptr_b = malloc(sizeof(int)); *ptr_b = 0;

if (fork()!=0) {

a = 2; *ptr_b = 4;

printf("%d %d\n", a, *ptr_b); } else {

a = 5;

*ptr_b = 7; printf("%d %d\n", a, *ptr_b);

}

4. Pensar en el mismo codigo, solo que en vez de procesos tenemos hilos.

Condiciones de Carrera

5. Dado el siguiente par de procesos que insertan datos en el spooler de impresion, donde cola es un espacio de memoria compartida y libre es una variable local a cada proceso.

P0:

P1:

.

.

libre := cola->fin+1;

libre := cola->fin+1;

cola->buffer[libre] := job4; cola->fin := libre;

.

cola->buffer[libre] := job5; cola->fin := libre;

.

1. Dar una planificacion o escenario que produce la perdida de un trabajo.

Situaciones en las que dos o más procesos leen o escriben en un área de memoria compartida y el resultado final depende de los instantes de ejecución de cada uno. Esto se soluciona impidiendo que más de un proceso acceda simultáneamente a las variables compartidas. Se soluciona garantizando la exclusión mutua

2. Dar una planificacion o escenario que funciona correctamente.

Spool tiene un número muy grande de entradas, numeradas 0, 1, 2,

,cada

una de ellas capaz de contener un nombre de fichero.

Imaginemos también que se tienen dos variables compartidas, out, que apunta al siguiente fichero a imprimir, e in, que apunta a la siguiente entrada libre en el directorio. Estas dos variables pueden caber perfectamente en un fichero de dos palabras disponible para todos los procesos. En un cierto momento, las entradas de la 0 a la 3

están vacías (al haberse imprimido ya los ficheros correspondientes) y las entradas de la 4 a la 6 están ocupadas (con los nombres de los ficheros encolados para su impresión). Más o memos simultáneamente, los procesos A y B deciden cada uno de ellos mandar a la cola de impresión un fichero

3. ?Cuantas planificaciones existen para estas 3+3 lineas de codigo?

?Cuantas son correctas y cuantas producen problemas? (determine el %)

6. Se tienen 2 procesos P0 y P1, P0 con N acciones atomicas y P1 con M acciones atomicas. Calcular cuantos escenarios posibles de ejecucion se pueden dar en un entorno concurrente.

7. Considere los procesos P0 y P1, con un valor inicial de x=0. ¿Cuales son los valores finales de x?

X=1(para ambos valores)

{ x=0 } P0: P1: x:=x+1; x:=x+1;
{ x=0 }
P0:
P1:
x:=x+1;
x:=x+1;

ALU, equivalentes al siguiente multiprograma. ?Cuales son los valores finales de x?

{ x=0 } P0: P1: A := x; A := x; A := A+1; A
{ x=0 }
P0:
P1:
A
:= x;
A := x;
A
:= A+1;
A := A+1;
x := A;
x := A;

Regiones Criticas

9. Mostrar que agregando un re-testeo de lock=0 luego del busy waiting en metodo de la variable candado, no soluciona nada.

Soluciones de Hardware

Deshabilitar las interrupciones.

mutexbegin ()

{

disable_ints;

}

mutexend ()

{

enable_ints;

}

Los problemas con este enfoque:

1. Desactivación interrumpe durante largos períodos de tiempo.

2. Hacer de E / S llamadas durante CS.

Instrucciones especiales de la máquina:

1.

Prueba y ajuste:

2.

int TAS (int & val)

3.

{

4.

int temp;

5.

6.

temp = val; / / Cuerpo realiza atómicamente.

7.

val = 1;

8.

volver temperatura;

9.

}

10.

Recuperar e incrementar:

11.

int FAI (int & val)

12.

{

13.

devuelven val + +; / / realiza atómicamente.

14. }

FAI solución al problema de CS para los procesos de n:

int nextTicket = 0, que sirve = 0;

mutexbegin ()

{

int myTicket;

myTicket = FAI (nextTicket);

mientras que (myTicket! porción =)

}

;

mutexend ()

{

+ + Porción;

}

La corrección de prueba:

1. La exclusión mutua: la contradicción.

Asunción: un proceso `` obras'' con variables de control.

2. Progreso: la inspección, no hay participación de los procesos que operan fuera de su CSS.

3. Limita espera: a lo sumo n myTicket más de servir.

Soluciones de Software

Dos Process Solutions

Ensayo: 1

Código de sección crítica:

A su vez int = 0; / * variable compartida de control * /

Pi: / * i es 0 o 1 * / while (turno! = i) / * Espera activa * / CSI; turn = 1 - i;

1.

Garantiza la exclusión mutua.

2. No garantiza el progreso --- cumplir alternancia estricta de los procesos que entran en CS.

3. Limita esperando violado --- Supongo que uno termina el proceso, mientras que su a su vez?

Trate de 2

Eliminar requisito de estricta alternancia

int flag [2] = {FALSO, FALSO} / * flag [i] indica que Pi se encuentra en su * / / * Sección crítica * /

mientras que (la bandera [1 - i])

;

flag [i] = TRUE; CSI; flag [i] = false;

1. La exclusión mutua violado

2. El progreso bien.

3. Limita esperar bien.

Trate de 3

Restauración de la exclusión mutua

int flag [2] = {FALSO, FALSO} / * flag [i] indica que quiere Pi * / / * Entrar en su sección crítica * /

flag [i] = TRUE;

mientras que (la bandera [1 - i])

;

CSI; flag [i] = false;

1. Garantiza la exclusión mutua

2. Viola el progreso --- ambos procesos podría crear la bandera y luego estancamiento en el tiempo.

3. Limita espera violado

Trate de 4

El intento de eliminar el punto muerto

int flag [2] = {FALSO, FALSO} / * flag [i] indica que quiere Pi * /

/ * Entrar en su sección crítica * /

flag [i] = TRUE; mientras que (la bandera [1 - i]) { flag [i] = false; demora; / * dormir por un tiempo * / flag [i] = TRUE;

}

CSI; flag [i] = false;

1. La exclusión mutua garantizada

2. Progreso violados (los procesos pueden bailar'', ``)

3. Limita espera violado

Algoritmo de Peterson

int flag [2] = {FALSO, FALSO} / * flag [i] indica que quiere Pi * /

/ * Entrar en su sección crítica * /

A su vez int = 0; a su vez / * indica que el proceso tiene * /

/ * Prioridad en entrar en su crítica * /

/ * Sección

flag [i] = TRUE; turn = 1 - i;

mientras que (la bandera [1 - I] && vez == 1 - i)

;

CSI; flag [i] = false;

1. Satisface todos los requisitos de la solución

Solución de proceso múltiple

El algoritmo de la panadería de Lamport

int elección [nprocs] = {FALSE} / * inicializador de hacer trampa * / int numero [nprocs] = {0}

la elección de [i] = TRUE;

número [i] = max (número) + 1;

la elección de [i] = false;

for (j = 0; j <nprocs; j + +) {

mientras que (la elección de [j])

;

al mismo tiempo (número de [j] = 0 && (número [j] <número de [i]! | |

número [j] == número de [i] && j <i))

;

}

CSI; número [i] = 0;

10. Mostrar que en alternancia estricta el proceso P0 puede impedir al P1 entrar a la CS aunque P0 este fuera de ella.

Solución de Peterson para la exclusión mutua 2-Proceso

1. Solución

Algoritmo de Peterson es la solución más simple sabe que el problema de

exclusión mutua para el caso especial de dos procesos, es decir, los procesos de

P i para i = 0 y 1.

Xvars (i) { boolean flag [0

/ / Flag [i] = true implica Pi tiene hambre o comer

A su vez entero: = 0 o 1;

1]: = false;

/

/ Su vez indica el proceso de mayor prioridad en caso de contención

}

de entrada (i) {

1: flag [i]: = true;

2: a su vez: = j; 3: la bandera, mientras que [j] = j, y a su vez se salte;

}

salida (i) {

4:

flag [i]: = false;

}

2.

Prueba de Seguridad

Es suficiente para mostrar el resultado de que cuando un proceso entra en el CS

el otro proceso no es en la CS.

Caso 1. Supongamos que P0 entra CS en el instante t1. Así, en el instante t1, ya sea la bandera [1] = falso o turno! = 1 (nota que este cuida la no-atómica si-condición de control).

Caso 1.1. Supongamos que la bandera [1] = false en el instante t1. A continuación, P1 no está en CS, ya que activa la marca de P1 [1] en true en

la entrada (1) y no lo cambia en el CS, y P1 no cambia la bandera [1]. final 1.1

Caso 1.2. Supongamos que gire! = 1 y la bandera [1] = true en el instante t1. Luego girar = 0 en el instante t1, debido a que es inicialmente 0 o 1 y se fija a 0 ó 1. Hacemos una prueba por reducción al absurdo. Supongamos que P1 es en el CS en el instante t1, y dejar que la última vez que entró en el CS en el tiempo t2 (<t1). Así, en t2, ya sea la bandera [0] = falso o turno! = 0.

o

o Caso 1.2.1. Supongamos que la bandera [0] = false en t2. A continuación, P0 está en NCS en el tiempo t2. Por lo tanto en algún

momento t3 en el intervalo (t2, t1), P0 conjuntos de recurrir a 1. De

t3

a t1, P0 no cambia la vuelta. De T2 a la T1, P1 permanece en el

CS, por lo tanto, P1 no puede establecer a su vez a 0. De ahí a su vez debe ser de 1 en t1. Contradicción.

1.2.1

final

o

Caso 1.2.2. Supongamos que gire! = 0 y la bandera [0] = true en t2.

A continuación, gire = 1 en t2. Durante (T2, T1), P1 permanece en

CS, por lo que no cambia a su vez. P0 no se puede establecer a su vez a 0. Por lo tanto diría que a su vez una en el instante t1.

Contradicción.

1.2.2 final

final 1.2

final 1

Caso 2. Supongamos que P1 entra en CS en el tiempo t1. Entonces tenemos que P0 no está en CS en la t1 en un argumento de simetría del Caso 1 [es decir, la sentencia de 1 con los identificadores de proceso, los índices de bandera, y convertir los valores intercambiados]. final 2

final de la prueba de seguridad

3. Prueba de Progreso para la P0

Supongamos que P0 se convierte en hambre a la hora t1 (es decir, se ejecuta 1). Tenemos que demostrar que P0 finalmente entra en el CS, es decir, se pasa de 3. En algún momento t2 (> t1), P0 inicia las pruebas de la condición en la 3 (ya que

1 y 2 no se puede bloquear).

Caso 1: P1 está pensando en t2. A continuación, la bandera [1] = false en t2, cuando P0 ejecuta 3, y P0 se pasa de

Caso 2: P1 es comer en t2. Luego girar a = 1 y P1 tiene que esperar (recordemos que ya ha demostrado la seguridad). Eventualmente, en algún momento t3 (> t2) P1 termina de comer y hace 4.

Caso 2.1: P1 P0 se queda pensando hasta el estado de las pruebas.

A continuación, se P0 3 pasado (en algún momento después de T3).

Caso 2.2: P1 se convierte en hambre a la hora de T4 (> t3) antes de P0 condición de las pruebas. Entonces P1 finalmente ejecuta 3, fijando a su vez a 0. Después de esto a su vez se mantiene en 0 y P0 con el tiempo se pasa de 3 (en algún momento después de la T4).

Caso 3: P1 tiene hambre en t2.

A continuación, la bandera [1] = true en t2, y a su vez determina quién va a comer

al lado.

Caso 3.1: P1 fue la última vez, para actualizar.

A continuación, gire = 0 en t2 y P0 se pasa de 3.

Caso 3.2: P0 fue la última vez, para actualizar.

A continuación, gire = 1 en T2, espera P0 y P1 se pasa de tres en algún momento

t3 (> T2). En este punto, P1 está comiendo y este caso se reduce a 2 caso. final de la prueba de progreso para P0

4. Prueba de progreso para la P1

Simétrica con el argumento de la prueba de progreso para P0.

5. Comentarios

Como puede ver, la prueba de progreso es más complicado que la prueba de seguridad. Esto es típico de los programas concurrentes, es decir, asegurar que un algoritmo logra progreso a menudo requiere de un pensamiento más cuidadoso que el de asegurar que el algoritmo no lo hace nada mal.

En la prueba de seguridad, se recurrió a la prueba por la contradicción en el caso 1.2. Mostrar este caso sin tener que recurrir a la contradicción. Usted tiene que manejar dos casos secundarios: (1) vuelta = 0 en el instante t1, porque P0 ajustarlo de forma que en algún momento en el pasado, y (2) Gire = 0 en el instante t1, ya que inicialmente fue así, y P0 no lo ha actualizado hasta el momento .

11.

Deshabilitar interrupciones no funciona para regiones criticas anidadas (una dentro de la otra). Reescribir Begin/EndRegion para arreglar este problema.

12. Generalizar la alternancia estricta a 3 procesos. Generalizarla a n.

13. Demostrar de manera rigurosa que el algoritmo de Peterson no adolece del problema de progreso de la alternancia estricta.

14. Demostrar de manera rigurosa que el algoritmo de Peterson cumple con la propiedad de seguridad de la Region Critica (#proc_in_cs≤1).

15. ¿Sigue cumpliendo con la propiedad de seguridad el algoritmo de Peterson si intercambiamos las 2 primeras asignaciones de su BeginRegion? Demostrar o dar contraejemplo.

16. Implementar un spin lock con TestInc.

atomic function TestInc(var lock:

integer):integer; result:=lock;

lock:=lock+1;

return result;

17. Implementar un spin lock con Swap.

atomic procedure Swap(var v,w: integer); tmp:=v; v:=w; w:=tmp;

Primitivas de sincronizacion

18. Dados 3 procesos P0, P1 y P2 que realizan las acciones A0, A1 y A2, poner P's y V's de semaforos antes y despues de las acciones para sincrinizarlos de manera tal que se ejecuten en secuencia A0,A1,A2. Especificar el/los valor/es inicial/es de el/los semaforo/s.

19. Implementar utilizando semaforos la Region Critica N-1, es decir dentro de la region critica puede haber a lo mas N-1 procesos.

El otro uso de los semáforos es la sincronización. Los semáforos entrada_llena yentrada_vacia son necesarios para garantizar que ocurran o no ciertas secuencias de sucesos. En este caso concreto, esos semáforos aseguran que el productor detiene su ejecución cuando el búfer está lleno, y que el consumidor detiene su ejecución cuando el búfer está vacío. Este uso es diferente de la exclusión mutua

Planificadores

20. Los planificadores RR mantienen una lista de todos los procesos listos para correr, donde cada proceso aparece exactamente una vez. ?Que pasaria si

hubiera 2 o mas apariciones de un proceso en la lista de procesos para correr? ?Para que serviria?

Si sólo hay una CPU disponible, es necesario hacer una elección para determinar cual de esos procesos será elsiguiente que se ejecute. La parte del sistema operativo que realiza esa elección se denomina el planificador (scheduler), y el algoritmo que se utiliza para esa elección se denomina el algoritmo de planificación.

DULCE ROSARIO ISIDRO PIEDRAS