Sistemas Operativos
M.Sc. Julián Esteban Gutiérrez Posada M.Sc. Luis Eduardo Sepúlveda Rodríguez
Recordemos: ¡ Cuando dos o más procesos cooperan para solucionar un problema, ya sea en un sistema con uno o varios procesadores, se dice que e s t o s p r o c e s o s t r a b a j a n d e f o r m a concurrente.
Recordemos: ¡ Dos procesos son concurrentes si el inicio de uno de ellos ocurre antes de la terminación del otro. ¡
Dos procesos son concurrentes si la ejecución de los procesos se traslapa en el tiempo.
¡
Un proceso puede verse afectado por otro cuando uno o más de los recursos de software o de hardware que necesita para operar correctamente, son requeridos o compartidos por más procesos.
¡
Para que existan procesos cooperativos es necesario que el sistema operativo brinde servicios de comunicación y sincronización, es decir, que los procesos puedan “hablar” para compartir información y controlar el acceso concurrente.
¡
Los mecanismos de sincronización tienen como objetivo: § El control de acceso a los recursos compartidos de
hardware o software.
§ La asignación de recursos. § El controlar el flujo de ejecución (el proceso P sólo
debe ejecutarse cuando se ejecute completamente el proceso Q).
Suponga que se tienen dos transacciones (A y B), las cuales se ejecutan en forma concurrente y comparten variables. … TransacciónA(); TransacciónB(); …
Detalle de las transacciones A y B según el tiempo de ejecución Tiempo
Transacción A
1
SaldoX = 2000
2
SaldoA = SaldoX
3 4 5
Transacción B
SaldoB = Saldo X SaldoX = SaldoA -‐ 1000 Saldo X = Saldo B -‐ 1000
El valor final de SaldoX es 1000, pero debería ser 0. Por lo anterior nos damos cuenta que no debe permitirse el acceso indiscriminado de procesos concurrentes a variables o recursos compartidos.
¡
El problema de la “Actualización perdida” se da por la no atomicidad de las instrucciones, es decir que las instrucciones pueden ser interrumpidas en medio de su ejecución (una instrucción de alto nivel, puede ser equivalente a más de una instrucción en lenguaje de máquina).
¡
Solución… respetar la sección crítica § Considere n procesos concurrentes, en los cuales, cada uno tiene una
zona en su código en la cual hace referencia a un componente compartido. A estas zonas de código se les conoce como secciones críticas.
§ Entonces si deseamos garantizar que cuando un proceso está
ejecutando su sección crítica, ningún otro proceso que tenga recursos compartidos con él, puede estar ejecutando su sección crítica.
Para poder garantizar una sincronización efectiva, han aparecido varias alternativas: ¡ Espera Activa ¡ Espera no activa
¡
Solución por software
¡
se basan en mantener los procesos que esperan entrar a su sección crítica, en un ciclo cuya condición se rompe cuando el proceso que estaba en su sección critica termina, y que se activa cada vez que un proceso obtiene acceso a su sección crítica.
¡
Los procesos que esperan, siguen gastando tiempo de procesamiento en verificar dicha condición para saber si quedan o no en el ciclo.
… EntrarEnSeccionCritica() { while( Condicion ); Condicion = TRUE; //SECCION CRITICA Condicion = FALSE; } …
¡
¡
Para evitar que un proceso gaste tiempo de procesador verificando una condición, mientras otro sale de la sección crítica, es necesario “dormirlo” (Sleep). Para dormir un proceso, basta con mover su PID a la lista de procesos en espera. Posteriormente cuando el otro proceso termine su sección crítica es necesario “despertarlo” (Wakeup) o mejor dicho, mover su PID nuevamente a la lista de procesos listos.
¡
Solución por software
¡
Una solución que utiliza espera no activa es realizada con semáforos (creados por E.W. Dijkstra en 1965).
¡
Imagine que existe un tipo de datos llamado S_Semaforo, el cual es una estructura de datos que tiene asociada una variable entera positiva y una cola (FIFO – First In, First Out) de ID de procesos.
… Struct S_Semaforo() { unsigned int Valor; T_Cola ColaPID; } …
¡
El sistema operativo, debe brindar dos funciones atómicas que manipulen los datos asociados a un semáforo, Wait y Signal.
¡
Los procesos no pueden modificar directamente los campos asociados a un semáforo, es decir, deben usar las funciones que brinda el sistema operativo.
¡
Solamente al momento de creación de un semáforo, es posible la asignación asignar un valor inicial a un semáforo.
Las funciones Wait y Signal se implementan en la forma en que se muestra a continuación: ¡ Al ejecutar Wait, se verifica si el valor del semáforo es igual a cero (0). ¡
Se obtiene el PID del proceso actual.
¡
Se coloca su PID en la cola del semáforo
¡
A través de una solicitud al sistema operativo, este proceso se duerme (estado de espera)
¡
Si por el contrario su valor es positivo, simplemente se disminuye en uno este valor.
Wait ( S_Semaforo ID_Sem ) { if ( ID_Sem.Valor == 0 ) { PID_Proceso = Obtener_PID_Proceso_Actual(); ID_Sem.Cola_ID.Ingrese (PID_Proceso); Sleep (PID_Proceso); } else ID_Sem.Valor = ID_Sem.Valor -1; }
¡
Si se ejecuta la función Signal, se retira el proceso de la cola del semáforo, se le pide al sistema operativo que lo despierte (lo pase de la lista de procesos listos). Así éste podrá pasar sin ningún problema a ejecutar su sección crítica.
¡
Por supuesto, todo esto es transparente para los procesos, debido a que sólo invocan las funciones Wait y Signal, no se preocupan de cómo están construidas.
Signal ( S_Semaforo ID_Sem ) { PID_Proceso = ID_Sem.Cola_ID.Retire(); if ( PID_Proceso =! NULL ) wakeup (PID_Proceso ); else ID_Sem.Valor = ID_Sem.Valor +1; }
S_Semaforo S S.Valor = 1
Hilo 1
Wait ( S ) // Acceso Signal( S )
Hilo 2
Wait ( S ) // Acceso Signal( S )
S_Semaforo E E.Valor = 1 Int Num_Lectores = 0 S_Semaforo L L.Valor = 1
Escritor(es)
Lector(es) Wait ( L ) Num_Lectores ++ If ( Num_Lectores == 1 ) Wait ( E ) Signal( L ) // Acceso a leer Wait ( L ) Num_Lectores -‐-‐ If ( Num_Lectores == 0 ) Signal ( E ) Signal( L )
Wait ( E ) // Acceso a escribir Signal( E )
S_Semaforo E E.Valor = 1 Int Num_Lectores = 0 S_Semaforo L, A L.Valor = 1 A.Valor = 5
Escritor(es)
Lector(es) Wait ( L ) Num_Lectores ++ If ( Num_Lectores == 1 ) Wait ( E ) Signal( L ) Wait ( A ) // Acceso a leer Signal ( A) Wait ( L ) Num_Lectores -‐-‐ If ( Num_Lectores == 0 ) Signal ( E ) Signal( L )
Wait ( E ) // Acceso a escribir Signal( E )
S_Semaforo S1, S2 S1.Valor = 0, S2.Valor = 0 P1
P2
P3
// Ejecución de P1 Signal( S1 )
Wait ( S1 ) Wait ( S2) // Ejecución de P2
// Ejecución de P3 Signal( S2 )
S_Semaforo S1, S2 S1.Valor = 0, S2.Valor = 0 P1
P2
Wait ( S2 ) // Ejecución de P1
// Ejecución de P2 Signal( S1 )
P3
Wait ( S1) // Ejecución de P3 Signal( S2 )