Sistemas Operativos Tema 7. Concurrencia

Transcripción

1 Contenidos Sistemas Operativos Tema 7. Concurrencia Sistemas concurrentes El problema de la sección crítica Semáforos Monitores José Miguel Santos Alexis Quesada Francisco Santana 1 2 Bibliografía Contenidos Fundamentos de Sistemas Operativos q S. Candela, C.R. García, A. Quesada, F.J. Santana, J.M. Santos. Thomson, 2007 q Capítulo 3 Programación Concurrente q J.T. Palma, M.C. Garrido, F. Sánchez, A. Quesada q Capítulos 1, 2, 3, 4, 5 y 6 Principles of Concurrent and Distributed Programming q M. Ben-Ari. Prentice Hall, 1990 Concurrent Programming q A. Burns, G. Davies. Addison-Wesley, 1993 q Capítulo 7 Sistemas concurrentes El problema de la sección crítica Semáforos Monitores 3 4 Modelo del sistema Qué es concurrencia? Conjunto de procesos cooperativos q Red de cajeros automáticos q Sistema de reserva de billetes q Servidor de impresión q Definición de diccionario: coincidir en el espacio o en el tiempo dos o más personas o cosas. En Informática, se habla de concurrencia cuando hay una existencia simultánea de varios procesos en ejecución. Ojo, concurrencia existencia simultánea no implica ejecución simultánea

2 Paralelismo y concurrencia El paralelismo es un caso particular de la concurrencia. Se habla de paralelismo cuando ocurre la ejecución simultánea de instrucciones. Procesos cooperativos Necesidades de sincronización y comunicación Los procesos concurrentes tendrán necesidad de comunicarse información Además, será necesario en ocasiones detener a un proceso hasta que se produzca un determinado evento o se den ciertas condiciones à sincronización 7 8 Técnicas de sincronización Basadas en memoria compartida q Inhibición de Interrupciones q Espera activa q Semáforos q Regiones críticas q Monitores Basadas en el paso de mensajes q Canales q Buzones Ejemplo 1: modificación concurrente de una variable procedure Ejemplo1 is x:integer; procedure P1 is x:=x+10; end P1; procedure P2 is if x>100 then Put_Line (x); else Put_Line (x- 50); end if; end P2; x:=100; COBEGIN P1; P2; COEND; end Ejemplo1; 9 10 Ejemplo 2: bucles infinitos concurrentes procedure Ejemplo2 is contador:integer; procedure Cuenta is espera a que pase un coche contador := contador+1; end Cuenta; procedure Imprime; espera una hora Put( Coches que han pasado: ); Put (contador); contador:=0 end Imprime; contador:=0; COBEGIN Cuenta; Imprime; COEND; end Ejemplo2; Ejemplo 3: búfer limitado N: constant integer:=; type elemento is ; buffer: array(0..n- 1) of elemento; entra,sale: mod N:=0; contador: integer range 0..N:=0; Productor producir_algo (elem); exit when contador<n; buffer(entra):=elem; entra:=entra+1; contador:=contador+1; Consumidor exit when contador>0; elem:=buffer(sale); sale:=sale+1; contador:=contador- 1; consumir (elem);

3 Problema al modificar datos compartidos Ambas rutinas son correctas si se ejecutan por separado pero podrían NO funcionar si se ejecutan de manera concurrente Supongamos que contador contiene en un momento dado el valor 5 y que las instrucciones contador=contador+1 y contador=contador-1 se ejecutan de forma concurrente ( contador podría ser 4, 5 o 6!) contador = contador + 1 contador=contador-1 registro 1 := contador; registro 2 := contador; registro 1 := registro 1 +1; registro 2 := registro 2-1; contador : registro 1 ; contador := registro 2 ; T0: productor registro 1 := contador (registro 1 = 5) T1: productor registro 1 := registro 1 +1 (registro 1 = 6) T2: consumidor registro 2 := contador (registro 2 = 5) T3: consumidor registro 2 := registro 2-1 (registro 2 = 4) T4: productor contador := registro 1 (contador = 6) T5: consumidor contador := registro 2 (contador = 4) Contenidos Sistemas concurrentes El problema de la sección crítica Semáforos Monitores Sección crítica: modelo del sistema N procesos intentan acceder a un recurso compartido en un bucle infinito: Sección_No_Crítica (SNC); Pre_Protocolo; Sección_Crítica (SC); Post_Protocolo; Sección crítica: segmento de código donde se accede a datos compartidos con otros procesos Sección crítica: modelo del sistema (2) Nunca puede haber más de un proceso en la sección crítica (exclusión mutua) Los pre y post protocolos serán algoritmos para garantizar que se cumple la exclusión mutua Requisitos de la solución Importante Exclusión mutua Progreso: si ningún proceso está en sección crítica y hay procesos que desean entrar en su s.c., sólo estos últimos participarán en la decisión y ésta se tomará en un tiempo finito. Espera limitada: hay un límite para el número de veces que otros procesos pueden adelantarse a un proceso que quiere entrar en s.c. Suponemos que cada proceso se ejecuta a una velocidad distinta de cero No podemos hacer suposiciones acerca de las velocidades relativas de los procesos

4 Solución trivial: cortar la multiprogramación Si suspendemos la multiprogramación, desaparece el problema de acceso a los datos compartidos pero perdemos todas las ventajas de la multiprogramación Hay que buscar una solución menos radical Solución del hardware: inhibir las interrupciones Antes de que un proceso entre en su sección crítica, se inhiben las interrupciones Así es imposible que el proceso sea expulsado de la CPU mientras está accediendo al dato compartido Al salir de la SC, se rehabilitan las interrupciones Inhibir las interrupciones: problemas Mientras un proceso está en SC, se suspende toda la concurrencia en el sistema à no se le da oportunidad a otros procesos que no están accediendo al recurso compartido Esta técnica no se puede implementar en un multiprocesador Soluciones con espera activa La sincronización se basa en que un proceso espera mediante la comprobación continua de una variable, manteniendo ocupada la CPU. Soluciones Software Soluciones Hardware Intento ingenuo: usar un indicador de disponibilidad - - variable global - - indica si la sección crítica está libre libre: boolean := true; - - código que ejecuta cada proceso sección no crítica exit when libre; libre := false; sección crítica libre := true; Primer intento serio: variable turno (solución para dos procesos) turno: positive range 1..2 := 1; SNC1; exit when turno=1; SC1; turno:=2; SNC2; exit when turno=2; SC2; turno:=1; proceso 1 proceso

5 Discusión del primer intento Segundo intento: avisadores Exclusión mutua? Espera limitada? Progreso? SNC1; exit when libre2; libre1:=false; SC1; libre1:=true; libre1, libre2: boolean := true; SNC2; exit when libre1; libre2:=false; SC2; libre2:=true; proceso 1 proceso Tercer intento SNC1; libre1:=false; exit when libre2; SC1; libre1:=true; libre1,libre2: boolean := true; SNC2; libre2:=false; exit when libre1; SC2; libre2:=true; proceso 1 proceso 2 Algoritmo de Peterson - FUNCIONA!! libre1, libre2: boolean := true; turno: positive range 1..2 := 1; SNC1; libre1:=false; turno:= 2; exit when libre2 or turno=1; SC1; libre1:=true; SNC2; libre2:=false; turno:= 1; exit when libre1 or turno=2; SC2; libre2:=true; Solución para N procesos: Algoritmo de la panadería (Lamport) cogiendonumero: array(1..n) of boolean := (others=>false); num: array(1..n) of natural := (others=>0); - código del proceso i Sección no crítica (i); cogiendonumero(i):=true; num(i) := 1 + MAX(num(1) num(n)); cogiendonumero(i):=false; for j in 1..N exit when not cogiendonumero(j); exit when i=j or num(j)=0 or num(j)>num(i) or (num(j)=num(i) and j>i); Sección crítica (i); numero(i):=0; Soluciones hardware Inhibir interrupciones (muy drástico) Instrucciones atómicas test-and-set o SWAP

6 Instrucciones atómicas Ejemplos de algoritmos Inventadas en los años 60. Permiten evaluar y asignar un valor a una variable de forma atómica. test-and-set(b): Pone B a true y devuelve el antiguo valor de B. (Evaluar-y-Asignar(B)) SWAP(A,B): Intercambia los valores de A y B. (Intercambiar(A,B)) Si disponemos de estas instrucciones, se simplifica muchísimo el problema de la sección crítica. Sección no crítica; exit when Test_and_Set(llave)=false; Sección crítica; llave:=false; usando test-and-set usando swap Sección no crítica; aux:=true; - - variable local! Swap(llave,aux); exit when aux=false; Sección crítica; llave:=false; Solución completa (test-and-set) esperando: array(0..n- 1) of boolean := (others => false); cerradura: boolean := false; j: mod N; llave:boolean; SNCi; esperando(i):=true; llave:=true; while esperando(i) and llave llave:=test_and_set(cerradura); esperando(i):=false; SCi; j:=i+1; while (j/=i) and not esperando(j) j:=j+1; if j=i then cerradura:=false; else esperando(j):=false; end if; Contenidos Introducción El problema de la sección crítica Semáforos Monitores Semáforos Edsger Dijkstra, 1965 Objetivo: herramienta universal para sincronizar procesos, que sirva como componente básico para construir algoritmos concurrentes Concepto de semáforo Dijkstra lo definió como una variable entera S con dos operaciones atómicas: P(S): esperar a que S>0; S:=S-1; V(S): S:=S+1; NOTA: el semáforo no puede adquirir valores negativos

7 Semáforos: otras notaciones P(s) = wait(s) = espera (s) V(s) = signal(s) = señal (s) (se utilizan varias notaciones para las operaciones de los semáforos, pero todas significan lo mismo) Ejemplo: sección crítica resuelta con semáforos Usamos un único semáforo inicializado a uno. Sección no crítica wait(s) Sección crítica signal(s) end; Semáforos: esperar por eventos y condiciones Se asocia un semáforo, inicializado a cero, al evento por el que queremos esperar. Cuando un proceso ha hecho que se cumpla una determinada condición, lo indica ejecutando un signal(c). Un proceso esperará a que la condición sea cierta mediante un wait(c). P1 S1; signal(c); S2; end; P2 R1; wait(c); R2; end; Semáforos: ejercicios Ejercicios q a.-) Resolver el problema de la sección crítica con n procesos q b.-) Resolver diversos problemas de sincronización b.1.-) Sean P1 y P2 dos procesos concurrentes. Modificar el código de ambos procesos de forma que el conjunto de sentencias R2 del proceso 2 se ejecute después de que se haya ejecutado el conjunto de sentencias S1 del proceso 1. P1 S1; S2; end; P2 R1; R2; end; Semáforos: ejercicios q b.2.-) Realizar un pequeño programa que se ajuste al siguiente diagrama (o grafo) de precedencia (suponiendo que disponemos de las herramientas siguientes: sentencia concurrente co/coend ) Semáforos: ejercicios q b.3.-) Realizar un pequeño programa que se ajuste al siguiente diagrama (o grafo) de precedencia (suponiendo que disponemos de las herramientas siguientes: sentencia concurrente co/coend y semáforos) A C A C B D B D

8 Semáforos: implementación con espera activa También llamados spinlocks wait(s): while s<=0 do nada; s:=s- 1; signal(s): s:=s+1; Semáforos: implementación sin espera activa Suponemos que el SO proporciona unas operaciones para bloquear y desbloquear procesos type Semáforo is record valor:integer; L: Lista<Proceso>; end record; wait(s): s.valor := s.valor- 1; if s.valor<0 then L.insertar(procesoActual); bloquear(procesoactual); end if; signal(s): s.valor := s.valor+1; if s.valor<=0 then L.extraer(proceso); despertar(proceso); end if; Semáforos: la implementación debe garantizar atomicidad Es crítico que las operaciones se ejecuten de forma atómica Entorno uniprocesador: q Inhibir interrupciones Entorno multiprocesador: q Instrucciones hardware especiales q Aplicar un algoritmo de sección crítica con espera activa Semáforos binarios Los semáforos vistos reciben el nombre de semáforo general o semáforo de conteo Un semáforo que sólo puede tomar los valores 0 y 1 recibe el nombre de semáforo binario Ejercicio Implementación de un semáforo de conteo con semáforos binarios Problemas clásicos de sincronización Problema del búfer limitado Problema de los lectores y escritores q 1er problema: prioridad para los lectores q 2º problema: prioridad para los escritores Problema de los filósofos comensales

9 Búfer limitado Productor producir un elemento elem wait(hayhuecos); wait(cerradura); buffer(entra):=elem; entra:=entra+1; signal(cerradura); signal(hayelementos); N: constant integer:=; type elemento is ; buffer: array(0..n- 1) of elemento; entra,sale: mod N:=0; hayelementos: Semaphore :=0; hayhuecos: Semaphore :=N; cerradura: Semaphore :=1; wait(hayelementos); wait(cerradura); elem:=buffer(sale); sale:=sale+1; signal(cerradura); signal(hayhuecos); consumir elemento elem Consumidor Lectores y escritores Esquema útil para gestionar el acceso a una base de datos: q Puede haber varios lectores accediendo a la BD de forma concurrente q Sólo puede haber un escritor trabajando q No puede haber lectores y escritores al mismo tiempo q y si se puede, que no haya inanición Lectores y escritores: dos variantes Primera variante: prioridad para los lectores q Si un escritor está esperando, se le pueden adelantar otros lectores q Ojo, riesgo de inanición para los escritores Segunda variante: prioridad para los escritores q Si hay escritores esperando por la BD, los lectores que van llegando nuevos se deben esperar hasta que todos los escritores finalicen q Ahora hay riesgo de inanición para los lectores Lectores y escritores: 1ª variante Lector wait(cerradura); nlectores:=nlectores+1; if nlectores=1 then wait(escritura); signal(cerradura); LEER DE LA BD; wait(cerradura); nlectores:=nlectores- 1; if nlectores=0 then signal(escritura); signal(cerradura); cerradura: Semaphore :=1; escritura: Semaphore :=1; nlectores: natural :=0; wait(escritura); ESCRIBIR EN LA BD; signal(escritura); Escritor Lectores y escritores: 2ª variante cerrojo : Semaphore := 1; escribiendo : boolean := false; nlec,nesc : natural := 0; Lector wait(cerrojo); while escribiendo or nesc>0 signal(cerrojo); wait(cerrojo); nlec := nlec + 1; signal(cerrojo); leer de la BD wait(cerrojo); nlec := nlec 1; signal(cerrojo); Escritor wait(cerrojo); nesc := nesc + 1; while escribiendo or nlec>0 signal(cerrojo); wait(cerrojo); nesc := nesc - 1; escribiendo := true; signal(cerrojo); escribir en la BD wait(cerrojo); escribiendo := false; signal(cerrojo); Los filósofos

10 Los filósofos: modelo simple Filósofos: ojo al interbloqueo palillo: array(0..4) of Semaphore := (others=>1); wait(palillo(i)); wait(palillo(i+1 mod 5)); COMER; signal(palillo(i)); signal(palillo(i+1 mod 5); PENSAR; La solución anterior puede entrar en un estado de bloqueo mutuo entre todos los filósofos à interbloqueo Posibles soluciones: q Algoritmo asimétrico filósofos pares/impares q Impedir a más de cuatro filósofos entrar a pedir los palillos q Coger los dos palillos de forma atómica (o coges los dos, o no coges ninguno) Los semáforos ayudan, pero tienen limitaciones Los semáforos son una herramienta de bajo nivel, que requiere un uso disciplinado y cuidadoso. Es muy fácil cometer errores de uso con semáforos. Veamos algunos ejemplos dónde está el fallo? Sem = 0 P (sem) sección crítica V (sem) dónde está el fallo? Más problemas Sem = 1 void rutina_en_exclusion_mutua () { P (Sem) código de sección crítica if ( error ) return; más código de sección crítica V (sem) Dos procesos que acceden a recursos compartidos: qué ocurre al ejecutarlos al mismo tiempo? Proceso 1 P (impresora) P ( disco ) usar disco e impresora V (disco) V (impresora) Proceso 2 P (disco) P ( impresora ) usar disco e impresora V (impresora) V (disco)

11 Herramientas de alto nivel Regiones críticas condicionales Objetivo: introducir en el lenguaje de programación herramientas de sincronización que sean más seguras que los semáforos Ejemplos: q Regiones críticas q Monitores y variables condición Abstracción de un bloque de código que accede a recursos compartidos. Garantiza exclusión mutua. El código sólo se ejecuta si la condición asociada a la región crítica es cierta. Ejemplo: region Búfer when Nelementos > 0 { // este código se ejecuta en exclusión mutua // y sólo se ejecuta si Nelementos > 0 consumir un elemento del búfer Nelementos = Nelementos 1; Regiones críticas condicionales Contenidos Se plantearon en 1972 (Brinch Hansen, Pascal Concurrente) Gran fuerza expresiva, el código queda mucho más legible y compacto Problema: implementación muy costosa, comparada con el código escrito a mano con semáforos Por ese motivo, nunca llegaron a prosperar como herramienta de uso común Introducción El problema de la sección crítica Semáforos Monitores Monitor Propuesto por Hoare (1972) Tipo abstracto de datos q Estructura de datos privada q Operaciones públicas + q Exclusión mutua q Sincronización (variables condición) Monitor: ejemplo básico monitor Contador { // operaciones públicas public Contador () { valor = 0; public void incrementa() { valor++; public int actual() { return valor; int valor; // variable interna privada ; Contador.incrementa(); V = Contador.actual(); Si varios procesos intentan manipular el monitor al mismo tiempo, van entrando de uno en uno: no puede haber más de un proceso trabajando con el monitor en cada momento

12 Monitor: estructura interna Variables condición Una variable condición sirve para gestionar una cola de espera por el monitor Dos operaciones q x.wait à bloquea al proceso y lo mete en la cola x q x.signal à desbloquea a un proceso de la cola x ; si no hay procesos en x, no hace nada Variables condición: ejemplo Monitor con variables condición monitor Contador { Condition cola; public Contador () { valor = 0; public void BloqueaHastaQueValgaDiez() { if ( valor < 10 ) { cola.wait(); public void Incrementa() { valor++; if ( valor == 10 ) { cola.signal(); int valor; ; colas asociadas a las variables condición x e y x y datos compartidos operaciones código de inicialización cola de ingreso Qué ocurre tras un signal Qué ocurre cuando un proceso P realiza una operación signal sobre una variable condición x y existe un proceso suspendido Q asociado a dicha variable? Estilo Hoare à se reanuda Q inmediatamente Estilo Mesa à Q se desbloquea, pero espera a que P abandone el monitor El estilo Mesa es el más utilizado en los lenguajes de programación actuales Qué ocurre tras un signal (2) Si varios procesos están suspendidos por la condición x y algún proceso ejecuta x.signal, qué proceso se reanuda? q FIFO à desbloqueamos al más antiguo q Por prioridades à conveniente en sistemas de tiempo real

13 Ejemplo: un semáforo implementado con un monitor monitor Semáforo { int valor; Condition cola; public Semáforo (int val) { valor = val; public void P() { while ( valor == 0 ) { cola.wait(); valor- - ; public void V() { valor++; cola.signal(); ; Ejemplo: búfer limitado monitor Búfer { Condition hayhuecos, hayitems; int nitems = 0; const int N = ; public void insertar (Item x) { while ( nitems==n ) { hayhuecos.wait(); introducir x en el búfer nitems++; hayitems.signal(); public Item extraer() { while ( nitems==0 ) { hayitems.wait(); Item x = extrae algo nitems- - ; hayhuecos.signal(); return x; ; Cómo se implementa un monitor monitor MiMonitor { public void oper1 ( ) { public void oper2 ( ) { ; El compilador genera un código parecido a este: El cerrojo garantiza que no puede haber más de un proceso dentro del monitor class MiMonitor { Semáforo cerrojo = 1; public void oper1 ( ) { cerrojo.p(); cuerpo de oper1 cerrojo.v(); public void oper2 ( ) { cerrojo.p(); cuerpo de oper2 cerrojo.v(); ; Cómo se implementa un monitor: variables condición monitor MiMonitor { Condition c; c.wait(); c.signal(); ; monitor MiMonitor { Semáforo cerrojo = 1; Semáforo c_queue = 0; int c_count = 0; c_count++; cerrojo.v(); // 1. libero el monitor c_queue.p(); // 2. me bloqueo en la cola cerrojo.p(); // 3. cuando me desbloqueen // debo recuperar el monitor if (c_count>0) { // si hay alguien esperando c_count- - ; // lo desmarco c_queue.v(); // y lo desbloqueo Monitores: ejemplos más avanzados Lectores y escritores (1) monitor BaseDatos { public EmpiezaLectura() { public TerminaLectura() { public EmpiezaEscritura() { public TerminaEscritura() { ; void Leer() { // Lo que debe ejecutar un lector BaseDatos.EmpiezaLectura(); leer de la BD BaseDatos.TerminaLectura(); void Escribir() { // Lo que debe ejecutar un escritor BaseDatos.EmpiezaEscritura(); escribir en la BD BaseDatos.TerminaEscritura();

14 Lectores y escritores (2) monitor BaseDatos { Condition leer, escribir; int nlec=0, lecesperan=0; bool escribiendo = false; public EmpiezaLectura() { while (escribiendo) { lecesperan++; leer.wait(); lecesperan- - ; nlec++; leer.signal(); // desbloquea en cadena al resto Lectores y escritores (y 3) ; public EmpiezaEscritura() { while (nlec>0 escribiendo) { escribir.wait(); escribiendo = true; public TerminaEscritura() { escribiendo = false; if (lecesperan > 0) { leer.signal(); else { escribir.signal(); public TerminaLectura() { nlec- - ; if (nlec==0) { escribir.signal(); Filósofos (1): especificación del monitor monitor MesaFilósofos { // estado interno del sistema const int N=5; Condition puedecomer[n]; enum Estado { pensando, hambriento, comiendo ; Estado estado[n] = { others => pensando ; // operaciones públicas (ver siguientes páginas) public CogePalillos ( int filosofo ) { public SueltaPalillos ( int filosofo ) { Filósofos (2): ejemplo de uso void VidaDelFilósofo ( int unfilosofo ) { { piensaunpoco(); MesaFilósofos.CogePalillos (unfilosofo); comearroz(); MesaFilósofos.SueltaPalillos (unfilosofo); // operación auxiliar interna private compruebaquepuedecomer ( int filosofo ) { ; Filósofos (3): rutina auxiliar // operación privada dentro del monitor MesaFilósofos private compruebaquepuedecomer ( int filosofo ) { int vecinoderecha = (filosofo+1) % N; int vecinoizquierda = (filosofo- 1+N) % N; if ( estado[vecinoizquierda]!= comiendo && estado[vecinoderecha]!= comiendo ) { estado[filosofo] = comiendo; puedecomer[filosofo].signal(); Filósofos (y 4): operaciones públicas del monitor public CogerPalillos ( int filosofo ) { estado[filosofo] = hambriento; compruebaquepuedecomer(filosofo); if ( estado[filosofo]!= comiendo ) { puedecomer[filosofo].wait(); public SoltarPalillos ( int filosofo ) { estado[filosofo] = pensando; int vecinoderecha = (filosofo+1) % N; int vecinoizquierda = (filosofo- 1+N) % N; compruebaquepuedecomer (vecinoderecha); compruebaquepuedecomer (vecinoizquierda);