Tema 1: INTRODUCCIÓN A LA PROGRAMACIÓN CONCURRENTE

Tema 1. Introducción a laProgramación ConcurrenteProgramación ConcurrenteDepto. de Lenguajes y Sistemas InformáticosUniversidad de Granada

Contenidos1. Concepto de concurrencia y programaconcurrente.2. Sincronización y exclusión mutua. Propiedadesde corrección.3. Consideraciones sobre el hardware. Sistemasmulticore y clusters.4. Introducción a los mecanismos de sincronizacióny comunicación de bajo nivel.5. Algoritmos de Exclusión Mutua en sistemas conmemoria compartida.

1. Concurrencia y programaconcurrentePrograma concurrente y Concurrencia• Programa secuencial: Declaraciones de datos + instrucciones(ejecución secuencial).• Programa concurrente: Conj. de programas secuenciales ordinariosejecutados como procesos paralelos (paralelismo abstracto).• Proceso: Ejecución de un programa secuencial.• Concurrencia: describe el potencial para ejecución paralela.– Solapamiento real o virtual de varias actividades en el tiempo

1. Concurrencia y programaconcurrenteProgramación concurrenteProgramación Concurrente• PC: Notaciones y técnicas de programación usadas para expresarparalelismo potencial y solucionar los problemas de sincronización ycomunicación.• Abstracción: La PC es independiente de la implementación delparalelismo.Justificación de la PC• Eficiencia: Obvia.• Calidad: Más natural especificar algunos sistemas en términos de variosprocesos secuenciales ejecutándose concurrentemente.– Ej.: Transacciones de reservas de vuelos.• Cada terminal se controla con un programa secuencial

1. Concurrencia y programaconcurrenteModelo abstracto. Entrelazamiento• Modelado del paralelismo– P: Programa concurrente consistenteen 2 procs.: P1 y P2.– P ejecuta cualquiera de las secuenciasde ejecución obtenidas entrelazandosecuencias de P1 y P2.• Independencia del entorno deejecución: El entrelazamiento preserva lacorrección.– No importa cómo sea la ejecución, elresultado debe ser consistente. En casocontrario, no sería posible razonarsobre la corrección.P1I11I12I13I14…P2I21I22I23I24…P: Posibles comp.I11I21I12I22I23I13I24…I11I12I13I21I22I23I14…I21I11I22I12I13I14I23…P: I1||I2I1≡ M=1I2≡ M=2ResultadoconsistenteM=1 ó M=2– Análisis de programas difícil.– Nº ejecuciones posibles ≈ ∞– Se requieren métodos formales

1. Concurrencia y programaconcurrenteModelo abstracto. Hipótesis del progreso finito• No suposición acerca velocidades absolutas/relativas de ejecución de losprocesos salvo que el tiempo de ejecución >0– Entender programa concurrente en base a:• sus procesos secuenciales + las interacciones entre ellos.– Ej.: Disco es más lento que una CPU pero el programa no debería asumir eso– Razones para diseñar un sistema indep. de suposiciones temporales:• Difícil detectar y corregir fallos• Naturaleza dinámica de la configuración• Hipótesis del Progreso Finito– Globalmente: Existe al menos 1 proc. preparado, es decir, eventualmente sepermitirá la ejecución de algún proceso.– Localmente: Se le permite la ejecución de una sección de código a un procesopor lo que completará su ejecución en un tiempo finito.

2. Sincronización y Exclusiónmutua. CorrecciónNotaciones para expresar ejec. concurrentePropuestas Iniciales: No separan definición proc. de la sincronización.Posteriores Propuestas: Separan conceptos e imponen estructura.Declaración de procesos: Rutinas específicas de programación concurrente Estructura del programa concurrente más clara.Sistemas Estáticos : Nº fijo de procesos/hebras.− Activación: sólo en la iniciación del programa− Ej.: Message Passing Interface (MPI-1).Sistemas Dinámicos: Nº variable de procesos/hebras− Activación: En cualquier momento de la ejecución− Ej.: OpenMP, Java Threads, Parallel Virtual Machine (PVM), MPI-2.

Creación de procesos no estructurada: FORK-JOINprogram P1;...............fork P2;...............join P2;...............2. Sincronización y Exclusiónmutua. CorrecciónCreación de procesosprogram P2;..............................end;Fork: Especifica que la rutina invocada puedecomenzar su ejecución.Join: Sincroniza la terminación rutina invocadaVentajas: práctica y potente, Creación dinámica(UNIX)Inconvenientes: no estructuración. Bucles, condicionales, etc.Creación de procesos estructurada: COBEGIN-COENDcobegin S1 | S2 | ... | Sn coend; ⇒ Ejecución concurrente de S1, S2,…, Sn• Termina cuando terminen todos los Si• Hace explícito qué rutinas van a ejecutarse concurrentemente• Estructura: 1 única entrada y 1 única salida Más fácil de entender

2. Sincronización y Exclusiónmutua. CorrecciónExclusión mutuaAsegura que una secuencia de sentencias (sección crítica) se tratacomo una operación indivisible.A1: Actividad del proceso P1A1 y A2 se excluyen mutuamenteA2: Actividad del proceso P2− La ejecución de A1 no puede solaparse con la ejecución de A2− Si ambas intentan ejec. simultáneamente Sólo una avanza, la otra se bloquea.Ej.: Asignación de recursos en S.O.Descripción Abstracta del problemarestopre-protocolosección crítica (corta)post-protocolo• Aseguran la E.M.• Baja sobrecarga

2. Sincronización y Exclusiónmutua. CorrecciónSincronizaciónSincronizaciónUn proceso no debe continuar su ejecución hasta que se cumpla otracondición más general → Sincronizar el proceso con la condición.Generalización de la E.M.− Se pueden usar técnicas similares para la soluciónGrafo de sincronización: muestra las restricciones de precedencia que determinancuándo una actividad puede empezar.− Cada flecha en el grafo es un paso de sincronización.A B C− Tiene que ser acíclico.D E FG H I

Corrección en Sistemas concurrentes: Las propiedades de corrección se definen entérminos de propiedades de sus secuencias de ejecución.−2. Sincronización y Exclusiónmutua. CorrecciónPropiedades de corrección. Tipos“Para todas las posibles ejecuciones de P …………”• Propiedades de seguridad (safety): deben cumplirse “siempre”.−Requeridas en especificaciones estáticas: “Nunca pasará nada malo”E.M. : 2 procesos nunca entrelazan ciertas subsecuencias de operaciones.Ausencia Interbloqueo (Deadlock): Un programa que no termina siempre realizará trabajo útil.Propiedades de Vivacidad (liveness): deben cumplirse “eventualmente”.−−−Son propiedades dinámicas difíciles de probar: “Realmente sucede algo”Ausencia de inanición (starvation): los procesos no son indefinidamente pospuestos.Tipo particular de propiedad de vivacidad : Equidad (fairness): Un proceso que deseeprogresar debe hacerlo con justicia relativa con respecto a los demás.Más ligado a la implementación y a veces incumplida: distintos grados

3. Consideraciones sobre elhardwareArquitecturas para programación concurrente• Arquitecturas básicas para programación concurrenteRed de interconexiónCPUCPUCPUCPUCPUCPUCPUCPUMecanismos de implementación de la concurrencia− Dependen fuertemente de la arquitectura− Consideran una máquina virtual que representa un sistema multiprocesador o un sistemadistribuido,−MemMonoprocesadorCPU alterna instruccionesde distintos procesosParalelismo VirtualMemoriaMultiprocesador dememoria compartidaDatos comunesMemParalelismo Real (o híbrido) proporciona una base homogénea para el sistema de procesos concurrentes.El tipo de paralelismo afecta a la eficiencia pero no a la correcciónMemMemSistema Distribuido• No memoria común• Red de interconexión

3. Consideraciones sobre elhardwareProcesadores multinúcleo (multicore)●●Arquitectura multicore: cada procesador contiene doso más núcleos que pueden ejecutar instrucciones deforma simultánea.Multiprocesador en un solo chip: el sistema operativopercibe cada núcleo como procesador independiente.– Teóricamente, paralelismo perfecto.●Ventajas:– Menor consumo y mejor disipación calor.●●– Mejor aprovechamiento multithreading.Ejemplos: AMD Athlon dual core (2), AMD OpteronBarcelona (4), Intel core duo (2), Intel quad core (4),SUN UltraSparc T1 Niagara(8), IBM Cell (8+1), ...Thread 1Futuro inmediato: Ordenadores basados en estatecnología y adaptación software al nuevo hardware. Thread 2Procesadoresvisibles al Sist.OperativoPPProductividad+

3. Consideraciones sobre elhardwareClusters de ordenadores●Conexión de ordenadores mediante red deinterconexión:●Cada ordenador con su memoria local yespacio de direcciones propio●Red de interconexión: envío/recepción demensajes.●El conjunto se ve como un únicoordenadorRed de Interconexión– Ventajas sobre multiprocesador específico● Disponibilidad a bajo costo de potentesestaciones de trabajo y PCs● Fácil incorporación de últimos avances enCPUs y redes● Es posible usar software ya existente omodificarlo●Inconveniente: Latencia significativa

4. Mecanismos de bajo nivelSistemas con memoria compartidaMecanismos de bajo nivel en sistemas con memoria comúnE.M. y sincronización: Los mecanismos dependen de la naturaleza síncronadel hardware.Métodos de sincronización por el procesador−−Hacer los procesadores ininterrumpibles.Sólo para procesadores individuales.Métodos de sincronización por la memoria (almacenamiento)−−La memoria puede servir sólo una petición de acceso al mismo tiempo.mayor rango de aplicabilidad.

4. Mecanismos de bajo nivelInhibición de interrupcionesInterrupciones inhibidas: Se posponen las nuevas interrupciones.Forzar E.M.: hacer ininterrumpible al proceso que ejecuta sección crítica.Ventaja: muy rápido, 1 instrucción máquinaInconvenientesImpide tratar eventos de tiempo real.Evitar S.C. largas.Excluye actividades no conflictivasNo esperas en una S.C.Falla en multiprocesadoresSeguridad: S.C. anidadas− E.M. relajadaABeginRegion…….…….…….…….EndRegionPROTOCOLOSPARA E.M.B…….BeginRegion…….EndRegion…….procedure BeginRegion;{ DisableInterrupts }procedure EndRegion;{ EnableInterrupts }

4. Mecanismos de bajo nivelCerrojos. LocksInstrucción atómica de sincronización por mem.: TestAndSet- Lee una variable- Le asigna un nuevo valoratomic function TestAndSet (Lock : Bool) : Bool;{TestAndSet := Lock;Cerrojos: Mecanismo de E.M. Lock := true; /* No importa el valor antiguo */} Adquirir en orden jerárquico. procedure BeginRegion ( var L : Lock);− Cada región se asocia a un grupo de variables compartidas Asociar un cerrojo con cada grupo.− Se necesitan varios cerrojos:type Lock = Boolean;{ while TestAndSet(L) do null; }procedure EndRegion ( var L : Lock);{ L := false }P1BeginRegion (L1)BeginRegion (L2)S.C.….BloqueoP2BeginRegion (L2)BeginRegion (L1)S.C.….

4. Mecanismos de bajo nivelCerrojos. PropiedadesPropiedades de los CerrojosVentajasCualquier nº de procesos y procesadores con almacenamiento compartido.Simple y fácil de verificar.Liberal.InconvenientesPermite inanición: Elección de proceso arbitraria.Usa espera ocupada: afecta a la eficiencia.

4. Mecanismos de bajo nivelSemáforos(Dijkstra, 1965)Mecanismo exitosoVar s: semaphore; // Variable con valores enteros positivosInicialización: Asignar un entero positivoP(s), wait::If (s>0) s-- else suspender proceso llamadorV(s), signal:: If (Hay algún proceso P suspendido en s) despertar P else s++Tipos de semáforos– Binarios: Valores 0 ó 1 para implementar Exclusión Mutua– Generales: enteros>=0 para Sincronización de condiciónE.M. con semáforosProgram EjemploMutexVar s: semaphoreProc. P1 {…}Proc. P2 {…}Main {s=1;cobegin P1;P2; coend;}Proc. P1 {while (true) {P(s); S.C.; V(s); …} }Proc. P2 {while (true) {P(s); S.C.; V(s); …} }

4. Mecanismos de bajo nivelMecanismos en sistemas distribuidos• No existe memoria común: No sincronización por almacenamiento.No monoprocesador : No sincronización por procesador.Paso de mensajes: Mecanismo para:−−Transmitir datos (comunicación): Los procesos envían/reciben mensajes en lugarde escribir/leer en variables compartidasSincronizar procesos: la recepción de un mensaje es posterior al envío.Ventajas:−−Portabilidad: Implementable en cualquier arquitectura ( multiproc, sist. distribuido).No son necesarios mecanismos de E.M.

4. Mecanismos de bajo nivelMecanismos en sistemas distribuidosMecanismos de bajo nivel en sistemas distribuidos• Primitivas básicas− Envío: send ( , )− Recepción: receive (, )• Esquema GeneralmensajeEmisorCANALReceptor

4. Mecanismos de bajo nivelEsquemas de identificaciónEsquemas de Identificación en la comunicación¿Cómo identifica el emisor al receptor del mensaje y viceversa?Dos posibilidades:– Denominación directa:Emisor identifica explícitamente al receptor y viceversaSe utilizan los identificadores de los procesos– Denominación indirecta:Los mensajes se depositan en almacenes intermedios que son globales a losprocesos (buzones).

4. Mecanismos de bajo nivelEsquemas de identificación.Denominación DirectaDenominación DirectaVentajas:− No hay retardo paraProduce (dato);send (dato , P2);}establecer la identificaciónInconvenientes−Cambios en la identificación requiere Recompilar− Sólo enlaces 1-1Process P1{dato:integer;P1Process P2{dato:integer;receive (dato , P1);Consume (dato);}P2Existen esquemas asimétricos−emisor identifica al receptor, pero el receptor no indica emisorReceive (dato, Id): En Id se devuelve el emisor del mensaje recibido.

Denominación IndirectaFlexibilidad: permite comunic. varios procs.Declaración estática/dinámica:−−• Tipos4. Mecanismos de bajo nivelEsquemas de identificación.Denominación IndirectaEstática: fija fuente/destino en tiempo de compilación.No apropiada en entornos cambiantes.Dinámica: + potente pero – eficienteCHANNEL OF INT BuzónProcess P1{dato:integer;Produce (dato);send (dato , Buzón);}P1Process P2{dato:integer;receive (dato , Buzón);Consume (dato);}BuzónP2Canales (1 a 1)P1 A P2P1 B P2• Tipo fijoBuzones generales (n a n) Puertos (n a 1)P1P2BP3P4• Destino: send de cualquier proc.• Fuente: receive de cualquier proc.• Implementación complicada.•Enviar mensaje y transmitir todos los lugares.•Recibir mensaje y notificar recepción a todos.P1P2BP3• Destino: send de cualquier proc.• Fuente: receive de un proc.• Implementación más sencilla.

Sincronización4. Mecanismos de bajo nivelSincronización en sistemas distribuidosCoincidencia temporal emisor/receptor: com. síncrona/asíncronaPaso de mensajes Síncrono: emisor se bloquea hasta receptor listo y viceversa.−−Intercambio de mensaje: punto de sincronización emisor/receptor.El emisor podrá hacer aserciones acerca del estado del receptor.−−Análogo: com. telefónica y chat. cita entre ambos.Sentencias bloqueantes: pueden retardar al invocador.Más fáciles de implementar pero menos flexibles.Proceso Asend (A,m)Proceso Asend (A,m)esperaCitaCitaProceso Breceive(A,m)esperaProceso Breceive(A,m)

4. Mecanismos de bajo nivelSincronización en sistemas distribuidos (2)– Paso de mensajes Asíncrono: Llamadas no bloqueantesExiste Buffer para almacenar los mensajesSend nunca retrasa.Análogo: Correo electrónico y foro.Proceso Asend (A,m)BufferProceso Breceive(A,m)

4. Mecanismos de bajo nivelSincronización en sistemas distribuidos(3)• Send con buffer llenoReceive con buffer vacío• Retrasar send hasta que haya espacio• Devolver código al invocador. (Chequeo)• Retrasar receive: es lo más frecuente• Devolver código.Simulación esquema síncrono con operaciones asíncronasProcess P1Process P2{dato:integer;{dato:integer;send (P2 , dato); receive (P2,confimación)} receive (P1 , dato); send (P1,confimación)}Combinaciones:−−Envío-recepción bloqueantes/no bloqueantes,Envío NO bloq.-recepción bloq.: muy útil que emisor pueda continuar después del envío.Recepción no bloqueante con tiempo de espera: Útil para evitar inanición

5. Algoritmos de Exclusión mutuaIntroducciónExisten soluciones hardware1965 : Aparecen soluciones software− Sucesión de soluciones + mejoras (eficiencia, calidad)− Valor didáctico: Propiedades de los algoritmos concurrentesTipos de algoritmos−−Centralizados (para arquitecturas con memoria compartida) Variables de estado + variable/s crítica/s (compartida/s) + Espera ocupada Nos centraremos en este tipoDistribuidos (para arquitecturas distribuidas) Soluciones para : Distribuir soluciones centralizadas Variables de estado + paso de mensajes (no hay variables compartidas)Equidad: propiedad de la implementación → Evita inanición

5. Algoritmos de Exclusión mutuaSolución con variable compartida y esperaocupadaEspera ocupada: Enfoque para conseguir exclusión mutua− Procesos esperan a la entrada de región hasta continuación segura.− Utilizan recursos computacionales sin ningún progreso (p.e. ejecutandocontinuamente un bucle vacío).− No cambian si no hay otro trabajo a realizar durante espera.VAR MutEx : Boolean = false;proc BeginRegion;{while MutEx do nothing;MutEx = true;}proc EndRegion;{MutEx = false;}• Sincronización por almacenamiento• Falla propiedad de seguridad

5. Algoritmos de Exclusión mutuaRefinamiento sucesivo de DijkstraCondiciones que ha de verificar un solución correcta– Dijkstra (1965) : Condiciones + pasos didácticos (prop. patológicas)– Derivación por refinamiento sucesivo del Algoritmo de Dekkeriii. No suposición acerca nº instrucciones o nº de procs. soportados– Excepto que instrucciones básicas tienen ejecución atómica.– Ejecución simultánea 2 insts. → Ejecución secuencial orden conocido• No suposición acerca velocidad entre competidores:– excepto que NO es cero.• Un proc. en S. no C. no puede evitar que otro entre en su S.C.• Alcanzabilidad (No interbloqueo):• Los procs. requiriendo acceso a S. C. no pueden ser indefinidamente retrasados.

5. Algoritmos de Exclusión mutuaRefinamiento sucesivo de Dijkstra. Etapa 11ª Etapa• Garantiza E.M.• No garantiza iii).– Alternancia• Procs. sólo puedenentrar en sucesión• Procesos con tasas deutilización dispares.Variables CompartidasVAR turn:{0,1} = 0 ó 1Protocolo para Pi:While (turn!=i) do nothing;turn=j;Solución• Propuesta de Solución– No garantiza E.M.Protocolo para Pi:turn=i;While (turn!=i) do nothing;turn=j;

5. Algoritmos de Exclusión mutuaRefinamiento sucesivo de Dijkstra. Etapa 22ª Etapa• Problema 1ª etapa– Almacena el nº del proc.que debe entrar.– Debe almacenar info. deestado para decidir• flag[i]=true → Pi en S.C.Variables CompartidasVAR flag:boolean [0..1] = false;Protocolo para Pi:While (flag[j]) do nothing;flag[i]=true;flag[i]=false;– No garantiza E.M.• Si Pi y Pj avanzan simultáneamente• No satisface ii): depende de la velocidad

5. Algoritmos de Exclusión mutuaRefinamiento sucesivo de Dijkstra. Etapa 33ª Etapa• Problema 2ª etapa– Pi puede comprobar flag[j]antes de que Pj lo modifique• Solución:– Intercambio 2 primeras líneas• Garantiza E.M.Variables CompartidasVAR flag:boolean [0..1] = false;Protocolo para Pi:flag[i]=true;While (flag[j]) do nothing;flag[i]=false;• No garantiza iv)– Si Pi y Pj avanzan simultáneamente → Interbloqueo

5. Algoritmos de Exclusión mutuaRefinamiento sucesivo de Dijkstra. Etapa 34ª Etapa• Problema 3ª etapa– Cuando Pi fija su estado,no conoce estado de Pj.• Solución: Pi pone flag[i] a true paraindicar intención de entrar.• No garantiza iv) ni ii)– Si Pi y Pj avanzansimultáneamente : Interbloqueo• Conclusión:– No basta con el estado de los procs.– Hace falta turno.Variables CompartidasVAR flag:boolean [0..1] = false;Protocolo para Pi:flag[i]=true;While (flag[j]){flag[i]=false;while flag[j] do nothing;flag[i]=true;}flag[i]=false;

5. Algoritmos de Exclusión mutuaAlgoritmo de DekkerAlgoritmo de DekkerVariables CompartidasVAR flag: boolean [0..1] = false;turn: {0,1} = 0 ó 1 /* Establece cortesía*/Protocolo para Pi:flag[i]=true;While (flag[j]) { if (turn==j) {flag[i]=false;while (turn==j) do nothing;flag[i]=true;}}turn=j;flag[i]=false;

5. Algoritmos de Exclusión mutuaAlgoritmo de Dekker. Excl. mutuaPrueba de corrección. E.M.• No utiliza instrucciones especiales– Respeta ii)• Demostrar manteniendo ii)– ¿Garantiza E.M.?– ¿Alcanzabilidad?• E.M.– Pi en S.C. → flag[j]=false.– Sólo Pi modifica flag[i].– Pi comprueba flag[j] sólo cuando flag[i]=true.– Pi en S.C. → (flag[i]=true → flag[j]=false).– (Pi en S.C) y (Pj en S.C.) → Falso : ABSURDOProtocolo para Pi:flag[i]=true;While (flag[j]) {if (turn==j){ flag[i]=false;while (turn==j)do nothing;flag[i]=true; }}turn=j;flag[i]=false;

5. Algoritmos de Exclusión mutuaAlgoritmo de Dekker. AlcanzabilidadPrueba de Alcanzabilidad• Caso A: Único Pi desea entrar → Encuentra flag[j]=false y entra• Caso B: P0 y P1 desean entrar (turn=0)• B.1.: P1 encuentra flag[0]=false → Entra• B.2.: P1 encuentra flag[0]=true → turn=0– Pasa a bucle interno y pone flag[1]=false– P0 encuentra flag[1]=true → turn=0– Sigue en bucle externo hasta flag[1]=false– P0 entra antes que P1Protocolo para Pi:flag[i]=true;While (flag[j]) {if (turn==j){ flag[i]=false;while (turn==j)do nothing;flag[i]=true; }}turn=j;flag[i]=false;

5. Algoritmos de Exclusión mutuaAlgoritmo de Dekker. No inaniciónPrueba de Inanición• Existe escenario de inanición• Depende hardware– Prioridad escritura sobre lectura memoria• P1 rápido y repetitivo||P0 en bucle interno• P1 sale de S.C. → pone turn=0• P0 encuentra turn≠1 → Sale bucle interno• P1 pone flag[1]=false– Vuelve flag[1]=true– Encuentra flag[0]=false– Entra en S.C. → Impide a P0 poner flag[0]=true• Acceso a flag[0] en E.M.Protocolo para Pi:flag[i]=true;While (flag[j]) {if (turn==j){ flag[i]=false;while (turn==j)do nothing;flag[i]=true; }}turn=j;flag[i]=false;

5. Algoritmos de Exclusión mutuaGeneralización a N procesos. Alg. De DijkstraAlgoritmo de Dijkstra para N procesos (1965)Variables CompartidasVAR flag : array[0..n-1] of (passive, requesting, in_cs); /* inic. a passive */turn : 0..n-1;Protocolo para Pi ( i=0..n-1)var j:0..n-1; /*Variable local*/repeat { flag[i] = requesting;while (turn != i) if flag[turn] = passive then turn = i;flag[i] = in_cs;j = 0; while (j < n) and (j = i or flag[j] != in_cs) j++}until j = n;/* Ahora se cumple: (flag[j] ≠ in_cs, para todo j≠i) y flag[i]=in_cs */flag[i] = passive;testd(i)

5. Algoritmos de Exclusión mutuaAlgoritmo de Dijkstra. Excl. mutuaPrueba de corrección. E.M.• Pi sólo puede entrar si testd(i)– (flag[j]≠in_cs, para todo j≠i) y(flag[i]=in_cs)• Sólo Pi puede poner flag[i]=in_cs• Sólo se comprueban los flag[...]después de asignarProtocolo para Pi ( i=0..n-1)var j:0..n-1; /*Variable local*/repeat {flag[i] = requesting;while (turn != i) if flag[turn] =passive then turn = i;flag[i] = in_cs;until testd(i);flag[i] = passive;• Sólo Pi puede entrar a su S.C.

5. Algoritmos de Exclusión mutuaAlgoritmo de Dijkstra. AlcanzabilidadPrueba de corrección. Alcanzabilidad• Pi intenta entrar → flag[i]≠passive• flag[i] == in_cs no implica turn=i• Varios Pi entran simult. bucle interno– Ponen turn=i (el último turn=k)– Ponen flag[i]=in_cs• Los que lleguen después– flag[turn]≠passive– No se asignan turn– Se quedan en primer bucleProtocolo para Pi ( i=0..n-1)var j:0..n-1; /*Variable local*/repeat {flag[i] = requesting;• Todos Pi abandonan 2º bucle interno: No cumplen testd(i)– Pi (i≠k) ponen flag[i]=requesting y vuelven al primer bucle interno– Pk vuelve bucle externo y al 2º bucle interno (turn=k)• Pk único con flag[k]=in_cs → Pk entra en S.C.while (turn != i) if flag[turn] =passive then turn = i;flag[i] = in_cs;until testd(i);flag[i] = passive;

5. Algoritmos de Exclusión mutuaAlgoritmo de Dijkstra. Inanición?Prueba de corrección. InaniciónVarios Pi piden entrar S.C. constantemente– Puede que siempre sea el mismo el último en hacer turn=i– No evita el peligro de inaniciónCondición Adicional Solución(v) Un proceso que intente entrar en su sección crítica será capaz de hacerlo enun tiempo finito.Otra Formulación– Debe un límite en el nº de veces que otros procesos pueden entrar en S.C. entreel momento en que un proc. hace su petición para entrar en su propia S.C. y elmomento en que realmente entra.– Tiempo máximo de espera =f(número de veces).

5. Algoritmos de Exclusión mutuaAlgoritmo de Peterson para 2 procesosAlgoritmo de PetersonVersión para 2 procesosVariables Compartidasflag : array[0..1] of boolean; /* inicializado a false */turn : 0..1; /* resuelve conflictos de simultaneidad */Protocolo para Pi ( i=0,1; j=(i+1) mod 2 )flag[i] = true;turn = i;while (flag[j] and turn==i) do;flag[i] = false;

5. Algoritmos de Exclusión mutuaAlgoritmo de Peterson para 2 procesos (2)Prueba de corrección. E.M.Supongamos P0 y P1 en S.C.flag[0]=flag[1]=trueCondiciones no pueden ser falsas al mismotiempoUno de ellos, Pi, entró primeroVariables Compartidasflag : array [0..1] of boolean;turn : 0..1;Protocolo para Piflag[i] = true;turn = i;while (flag[j] and turn==i) do;flag[i] = false;Encontró turn=jPj no puede entrar, turn=j lo impide

5. Algoritmos de Exclusión mutuaAlgoritmo de Peterson para 2 procesos (3)Prueba de corrección. Alcanzabilidad + EquidadSuponer P0 esperando continuamente• P1 sale de S.C.• flag[1]=false → P0 entra a S.C.• P1 esperando entrar• IMPOSIBLE: Pturn debe entrar• P1 monopoliza acceso a S.C.• P1 pone turn=1 al intentar entrar denuevo → P0 entra a S.C.Variables Compartidasflag : array [0..1] of boolean;turn : 0..1;Protocolo para Piflag[i] = true;turn = i;while (flag[j] and turn==i) do;flag[i] = false;

5. Algoritmos de Exclusión mutuaAlgoritmo de Peterson para N procesosAlgoritmo de Peterson para N procesosGeneralización: Iterar solución para 2 procs., eliminando 1 proc. cada vez.Variables Compartidasflag : array[0..N-1] of -1..n-2; /* inicializada a –1 */turn : array[0..N-2] of 0..n-1; /* inicializada a 0 */Protocolo para Pi ( i=0,...,N-1)j:0..N-2; /* variable local indicando la etapa */for j = 0 to N-2{flag[i] = j;turn[j] = i;while [(∃ k ≠ i : flag[k] ≥ j) ∧ (turn[j] == i)] do; }flag[i] = -1;-1 ⇒ Pi no ha entrado en suprotocolo de entrada.j>=0 ⇒ Pi está en la j-ésimaetapa del protocolo.Pi1 precede a Pi2 ⇔ flag[i1]>flag[i2].

5. Algoritmos de Exclusión mutuaAlgoritmo de Peterson para N procesos (2)Lema 1. Un proc. que precede a todos los demás puede avanzar al menos 1etapa.Demostración:Supongamos Pi llega a bucle interno y se verifica:(No ∃ k ≠ i : flag[k] ≥ j) (1)• (1) se mantiene ⇒ Pi puede avanzar a etapa j+1.• (1) deja de ser cierta ⇒ algún Pr hace flag[r]←j.En cuanto, turn[j]=r ⇒ Pi podría continuar.Pi ( i=0,...,N-1)for j = 0 to N-2{flag[i] = j;turn[j] = i;while [(∃ k ≠ i : flag[k] ≥ j)∧ (turn[j] == i)]do;}flag[i] = -1;Si más de un proceso adicional se une a etapa j, Pi podría seradelantado.

5. Algoritmos de Exclusión mutuaAlgoritmo de Peterson para N procesos (3)Lema 2. Cuando un proceso avanza de la etapa j a la etapa j+1, se mantieneexactamente una de las siguientes condiciones:(a) el proceso precede a todos los demás procesos, o(b) el proceso no está solo en la etapa j.Nota: "Pi avanza una etapa" se refiere al instante de almacenar nuevo valor enflag[i].Demostración:Si Pi está a punto de avanzar flag[i]. Entonces ocurre una de estas cosas: Se cumple (1) ⇒ (a), o turn[j] ≠ i ⇒ Pi no último en etapa j ⇒ ∃ Pr tal que turn[j]=r ⇒ (b).

5. Algoritmos de Exclusión mutuaAlgoritmo de Peterson para N procesos (4)Lema 3. Si hay (al menos) dos procesos en la etapa j, habrá (al menos)un proceso en cada etapa k, 0 ≤ k ≤ j-1.Demostración: Inducción sobre j.(j=0): Condición nula.(j=1): Si hay al menos 2 procs. en etapa 1, el último que entrara en laetapa tuvo que dejar, por Lema 2, a otro en etapa 0.(j → j+1)?: Supongamos al menos 2 procesos en etapa j+1, cuando elúltimo se unió, por Lema 2, había al menos 2 procs. en etapa j. Por lahipótesis de inducción, las etapas precedentes estaban ocupadas y, porLema 2, estas etapas no pudieron haber sido desocupadas desdeentonces.

5. Algoritmos de Exclusión mutuaAlgoritmo de Peterson para N procesos (4)Lema 4. El número máximo de procs. en etapa j es n-j, 0

5. Algoritmos de Exclusión mutuaAlgoritmo de Peterson para N procesos.CorrecciónPrueba de corrección. Algoritmo de PetersonExclusión MútuaLa etapa n-2 contiene como mucho 2 procesos (Lema 4). Si hay sólo uno allí, yotro está en su S.C., Lema 2 dice que no puede avanzar para entrar en su S.C..Cuando la etapa n-2 contiene 2 procs., no hay ninguno en la etapa n-1 (S.C.), yuno de los 2 puede entrar. Para el proc. que queda no se cuple condición delbucle interno.AlcanzabilidadSiempre existirá un proc. que precede a todos los demás → puede avanzar porLema 1 o está acompañado en la etapa ocupada más alta → si no fue el últimoen entrar, avanzará.EquidadSi un proceso intenta continuamente avanzar, en el peor de los casos, el númeromáximo de turnos que tiene que esperar sería: d(N)=N(N-1)/2.