SISTEMAS OPERATIVOS Sección Crítica

Contenido Introducción Condiciones de competencia El problema del productor -consumidor Sección crítica. Exclusión mutua con espera ocupada. Bibliografía: Tanenbaum, A. S. Sistemas Operativos Modernos. Ed. Prentice-Hall Hispanoamericana, 1996, pp. 38-47. Operating Systems Concepts, Peterson and Silberschatz, pág 326-340.

Procesos concurrentes que comparten datos memoria compartida archivo de datos1 archivo de datos 2 archivo de datos n proceso Pi genera datos proceso Pj lee datos

Ejemplo: problema del productor-consumidor proceso productor proceso consumidor ¿? ¿? almacén común

Condiciones de competencia Situaciones en las cuales dos o más procesos acceden en forma simultánea a datos compartidos, y el resultado del procesamiento depende del orden en que las instrucciones se ejecuten.

Una solución al problema productor-consumidor N: número máximo de elementos admitidos en almacén counter: contador de elementos en almacén void productor () { REPETIR producir un elemento (item) WHILE (counter=N); almacenar (item) incrementar counter FIN } void consumidor () { REPETIR WHILE (counter=0); retirar (item) decrementar counter consumir (item) FIN } main() { parbegin productor () consumidor () parend; }

Dificultades de la solución Cuando un proceso llega a espera ocupada, el otro no podrá ocupar la CPU (supuesto un CPU). Ej: el consumidor espera debido a que el almacén está vacío y el productor no puede generar ya que el procesador lo tiene el consumidor El proceso que está en espera consume tiempo improductivo de CPU (supuesto 2 CPU). Solución posible: Quantum de tiempo por proceso El bloqueo del proceso cuando debe esperar

Primitivas de bloqueo sleep (): Implica que el proceso que la ejecuta pasa al estado de bloqueado. wake_up (proceso): pasa el proceso del estado de bloqueado al estado de listo.

Solución al problema productor-consumidor (con bloqueo) void productor () { REPETIR producir un elemento (item) IF counter=N THEN sleep(); almacenar (item) incrementar counter IF counter = 1 THEN wake_up (consumidor) FIN } void consumidor () { REPETIR IF counter=0 THEN sleep(); retirar (item) decrementar counter IF counter = N-1 THEN wake_up (productor) consumir (item) FIN } Para sincronizar los procesos se requiere que ellos compartan datos (en este caso la variable counter y el almacén)

Condiciones de concurrencia Sean S1 = counter + 1 y S2 = counter - 1 R(S1) = R(S2) = W(S1) = W(S2) = {counter} R(S1) ∩ W(S2) = {counter} ≠ {} R(S2) ∩ W(S1) = {counter} ≠ {} W(S1) ∩ W(S2) = {counter} ≠ {} Si ambos procesos ejecutaran concurrentemente S1 y S2 counter podría tomar un valor incorrecto.

Exclusión mutua y Sección Crítica Exclusión mutua: asegurar que unos procesos no puedan utilizar una variable o archivo compartido si otro proceso lo está utilizando. Sección Crítica: segmento de código de un proceso que accede a variables, ficheros u otros elementos que son comunes con otros procesos. Implementar exclusión mutua consiste en diseñar un protocolo que utilicen los procesos para ejecutarse en forma cooperativa, donde cada proceso debe solicitar entrar en su sección crítica.

Exclusión mutua usando secciones críticas A sale de la sección crítica A entra en la sección crítica trata de entrar en s. crítica entra en s. crítica sale de s. crítica bloqueado Tiempo

El problema de la sección crítica Situación: se tienen n procesos P1, P2, … Pn sección de entrada Sección crítica modifica var. comunes actualiza archivos, tablas, etc. sección de salida sección restante Cuando Pi ejecuta su sección crítica ningún otro proceso puede ejecutar la suya.

Condiciones para lograr paralelismo correcto y eficiente Exclusión mutua: No pueden haber al mismo tiempo dos procesos en sus respectivas secciones críticas. Sin suposiciones: No se deben hacer hipótesis sobre la velocidad o la cantidad de procesadores. Progreso: Ningún proceso que se encuentre fuera de su sección crítica puede impedir que otro entre en la suya. Límite de tiempo: Ningún proceso deberá esperar tiempo arbitrariamente largo para entrar en su sección crítica.

Exclusión mutua con espera ocupada Algoritmo de Peterson: considera que si un proceso debe esperar lo hace en forma ocupada y no bloqueado Consideraciones: Se supondrá que interviene solamente 2 procesos identificados como Pi y Pj (P0 y P1). Ambos procesos utilizan el mismo algoritmo, pero con los índices i y j intercambiados. Hay 2 cantidades comunes para ambos procesos: turno (Pi o Pj) y interesado[proceso P] (TRUE o FALSE).

Algoritmo de Peterson REPETIR interesado[Pi] =TRUE; /* Sección entrada */ turno = Pj; WHILE turno= Pj AND interesado[Pj]); sección_crítica(); interesado[Pi] = FALSE; /* Sección salida */ sección_restante(); FIN Un proceso P entra en su sección crítica cuando: P tiene derecho al turno o, El otro proceso tiene derecho al turno, pero éste no está interesado o, Ambas.

Algunas preguntas REPETIR interesado[Pi] =TRUE; /* Sección entrada */ turno = Pj; WHILE turno= Pj AND interesado[Pj]); sección_crítica(); interesado[Pi] = FALSE; /* Sección salida */ sección_restante(); FIN ¿Si ambos procesos tratan de entrar concurrentemente en su sección crítica? 2. Un inconveniente importante del algoritmo 3. ¿Qué puede ocurrir si un proceso de prioridad baja se está ejecutando en su sección crítica?