E - Departamento de Informática Aplicada

E. U. de Informática
Departamento de Informática Aplicada
Examen Final de Sistemas Operativos I
EJERCICIO 2 (4 puntos)
4 de septiembre de 2006
Tiempo estimado: 80 min.
Sobre un ordenador monoprocesador se tiene un sistema operativo multiproceso en el que los
procesos utilizan los protocolos entrar_RC y salir_RC siguientes para acceder a una determinada
región crítica:
int cerrojo_Global = 0 ;
/* variable global compartida. 0 => RC libre */
...
void entrar_RC ( ) {
/* entrar en la region critica */
int permisoDeEntrada = FALSE ;
/* variable local (pila del proceso)*/
while (permisoDeEntrada == FALSE) {
/* bucle de espera activa */
Inhibir_interrupciones ;
if (cerrojo_Global == 0) { cerrojo_Global = 1 ;
/* 1 => RC ocupada */
permisoDeEntrada = TRUE ;
}
Permitir_interrupciones ;
}
}
void salir_RC ( ) {
cerrojo_Global = 0 ;
}
/* salir de la region critica */
/* 0 => RC libre */
En una hoja aparte se muestran las características de tres procesos A, B y C, así como (a modo
de ejemplo) el seguimiento de su ejecución desde el instante t = 0 milisegundos hasta el instante t =
55 milisegundos utilizando el algoritmo de planificación FCFS (First-Come First-Served) en el
sistema anteriormente descrito.
Se pide:
1) [2 puntos] Realizar el seguimiento de los tres procesos anteriores utilizando el algoritmo de
planificación Round Robin con rodajas de tiempo de 3 milisegundos.
2) [1 punto] Realizar el seguimiento de los tres procesos anteriores utilizando el algoritmo de
planificación Round Robin por prioridades con rodajas de 3 milisegundos. Un detalle que
deberá tenerse en cuenta es que si llega a la cola de preparados un proceso más prioritario
que el proceso en ejecución, dicho proceso deberá esperar a que el proceso actual consuma
su rodaja antes de que el planificador lo seleccione para pasar a ejecución.
3) [1 punto] Si se ha hecho correctamente el seguimiento del apartado 3, se habrá apreciado la
existencia de un problema conocido como “el problema de la inversión de prioridades”.
Precisar dentro del seguimiento del apartado 2 en qué instante se da ese problema.
Explicar informalmente cómo podría resolverse ese problema modificando ligeramente los
protocolos entrar_RC y salir_RC haciendo uso de la función:
int poner_Prioridad ( int prioridad ) ;
que establece la prioridad del proceso en ejecución al valor indicado como parámetro, y
devuelve como resultado la prioridad original del proceso.
E. U. de Informática
Departamento de Informática Aplicada
Examen Final de Sistemas Operativos I
4 de septiembre de 2006
EJERCICIO 2
Ejecución de los procesos A, B y C en un sistema con protocolos entrar_RC y salir_RC.
Cada proceso tiene su propio disco duro pudiendo trabajar en paralelo.
Significado de la notación utilizada para representar el estado de los procesos:
En ejecución
Preparado
En espera/Bloqueado
e = fin de entrar_RC( )
s = salir_RC( )
En la fila V se indica el valor de cerrojo_Global
Algoritmo de planificación FCFS (First-Come First-Served)
Proceso: A
llega en t = 0
prioridad = 5
Proceso: B
llega en t = 7
prioridad = 3
Proceso: C
llega en t = 9
prioridad = 5
A1: CPU(1)
A2: entrar_RC( )
A3: CPU(1)
A4: E/S(4)
A5: CPU(1)
A6: salir_RC( )
A7: CPU(1)
A8: E/S(4)
volver a empezar
B1: CPU(1)
B2: entrar_RC( )
B3: CPU(1)
B4: E/S(4)
B5: CPU(1)
B6: salir_RC( )
B7: CPU(1)
B8: E/S(4)
volver a empezar
C1: CPU(1)
C2: entrar_RC( )
C3: CPU(1)
C4: E/S(4)
C5: CPU(1)
C6: salir_RC( )
C7: CPU(1)
C8: E/S(4)
volver a empezar
V 0 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
llega C
C1
C
llega B
B
e
B1 B3
e
A A1 A3
1
2
0
s
4
e/s sector
disco A
3
4
A5 A7
6
5
7
8
C nunca sale del bucle while de entrar_RC( ) ya que cerrojo_Global siempre vale 1
4
e/s sector
disco B
4
e/s sector
disco A
9
11 12 13 14
10
16 17 18 19
15
21 22 23 24
20
26
25
27 28 29
31 32 33 34
30
llega A
(escala de tiempos en milisegundos)
36 37 38 39
35
41 42 43 44
40
46 47 48 49
45
51 52 53 54
50
55
E. U. de Informática
Departamento de Informática Aplicada
Examen Final de Sistemas Operativos I
4 de septiembre de 2006
Apellidos ...................................................................................................................
Nombre .....................................................................................................................
Nº de matrícula .........................................................................................................
HOJA DE RESPUESTAS
EJERCICIO 2
Proceso: A
llega en t = 0
prioridad = 5
Proceso: B
llega en t = 7
prioridad = 3
Proceso: C
llega en t = 9
prioridad = 5
A1: CPU(1)
A2: entrar_RC( )
A3: CPU(1)
A4: E/S(4)
A5: CPU(1)
A6: salir_RC( )
A7: CPU(1)
A8: E/S(4)
volver a empezar
B1: CPU(1)
B2: entrar_RC( )
B3: CPU(1)
B4: E/S(4)
B5: CPU(1)
B6: salir_RC( )
B7: CPU(1)
B8: E/S(4)
volver a empezar
C1: CPU(1)
C2: entrar_RC( )
C3: CPU(1)
C4: E/S(4)
C5: CPU(1)
C6: salir_RC( )
C7: CPU(1)
C8: E/S(4)
volver a empezar
1) [2 puntos] Realizar el seguimiento de los procesos A, B y C utilizando el algoritmo de
planificación Round Robin con rodajas de tiempo de 3 milisegundos.
Cada proceso tiene su propio disco duro pudiendo trabajar en paralelo.
En ejecución
Preparado
En espera/Bloqueado
e = fin de entrar_RC( )
Nº Orden
CON SOLUCIÓN
s = salir_RC( )
En la fila V se indica el valor de cerrojo_Global
V 0 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1 1
llega C
C
C1
llega B
B
e
s
B1 B3
e
s
A A1 A3
1
2
0
4
e/s sector
disco A
3
4
A5 A7
6
5
7
8
4
e/s sector
disco B
4
e/s sector
disco A
9
B5 B7
e
A1
A3
11 12 13 14
10
4
e/s sector
disco B
16 17 18 19
15
B1
B3
s
4
e/s sector
disco A
21 22 23 24
20
s
e
A5 A7
26
25
27 28 29
4
e/s sector
disco C
4
e/s sector
disco A
31 32 33 34
30
llega A
(escala de tiempos en milisegundos)
B5 B7
e
A1
A3
36 37 38 39
35
4
e/s sector
disco C
41 42 43 44
40
B1
4
e/s sector
disco C
46 47 48 49
45
51 52 53 54
50
55
1
2) [1 punto] Realizar el seguimiento de los tres procesos A, B y C utilizando el algoritmo de planificación Round Robin por prioridades con rodajas de 3
milisegundos. Un detalle que deberá tenerse en cuenta es que si llega a la cola de preparados un proceso más prioritario que el proceso en ejecución, dicho
proceso deberá esperar a que el proceso actual consuma su rodaja antes de que el planificador lo seleccione para pasar a ejecución.
Proridad A = 5
Prioridad B = 3
Prioridad C = 5
V 0 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
llega C
C1
C
llega B
B
e
B1 B3
e
A A1 A3
1
0
2
s
4
e/s sector
disco A
3
4
A5 A7
6
5
7
8
4
e/s sector
disco B
4
e/s sector
disco A
9
A1
11 12 13 14
10
16 17 18 19
15
21 22 23 24
20
26
25
27 28 29
31 32 33 34
30
36 37 38 39
35
41 42 43 44
40
46 47 48 49
45
51 52 53 54
50
3) [1 punto] ¿En qué instante del seguimiento anterior se aprecia “el problema de la inversión de prioridades”? Razonar la respuesta
El peligro comienza a partir del instante t = 10 ya que el proceso B tras entrar en la región crítica se bloquea para hacer entrada/salida, por lo que pierde la
posesión de la CPU a favor de procesos de mayor prioridad que van a intentar infructuosamente entrar en la región crítica. Como el proceso B nunca
vuelve a obtener la CPU, no puede salir de la región crítica. Como la región crítica está ocupada por B, ni A ni B conseguirán retornar de la función
entrar_RC( ). En resumen, ni A, ni B, ni C avanzan en la ejecución de instrucciones verdaderamente productivas.
Explicar informalmente cómo podría resolverse ese problema utilizando la función: int poner_Prioridad ( int prioridad ) ;
El proceso B debería aumentar su prioridad tan pronto como consigue entrar en la región crítica, por lo menos al valor 5 para asegurar que podrá seguir
avanzando en la ejecución de las instrucciones de la región crítica. Más concretamente se necesitaría una variable global para guardar la prioridad del
proceso que entra en la región crítica. En el momento de poner a 1 el cerrojo debe llamarse a la función poner_Prioridad(5), lo que asegurará que B
conseguirá salir de la región crítica sin problemas. Cuando se llame a salir_RC( ) se restablecerá la prioridad inicial del proceso que sale de la región
crítica.
55