Soluciones
del examen parcial, año 2001
30
de abril de 2001
Pregunta
1. TEST
Pregunta
|
Opción
correcta
|
1
|
d
|
2
|
b
|
3
|
b
|
4
|
a
|
5
|
b
|
6
|
b
|
7
|
d
|
8
|
a
|
9
|
a
|
10
|
b
|
11
|
d
|
12
|
B,c*
|
*:
la opción (a) podía inducir a confusión, así que se
aceptan estas dos respuestas.
Pregunta
2. Cuestiones de respuesta corta
- ¿Tiene
sentido un sistema monousuario que sea también multiprogramado?
Por
supuesto que sí. La multiprogramación siempre contribuye a
aumentar el rendimiento de los recursos, ya que saca más partido del
procesador. Además, a un usuario individual le puede resultar muy
útil tener varios programas en ejecución simultánea, como
ocurre en un entorno de ventanas típico, en el cual el usuario puede
tener abiertas varias aplicaciones al mismo tiempo. Esto permite aumentar la
productividad del usuario, ya que no ha de esperar a que una aplicación
finalice para trabajar con otro programa.
- ¿Por
qué el algoritmo FCFS (en orden de llegada) de planificación de
procesos no es apropiado para sistemas multiusuarios e interactivos?
El
algoritmo FCFS no tiene la capacidad de expulsar del procesador a un proceso
que no lo solicite. Por este motivo, un proceso intensivo en CPU puede acaparar
el procesador por tiempo indefinido, postergando a los restantes procesos
preparados. Esto significa que un programa interactivo, que exige tiempos de
respuesta bajos, pueda verse retrasado un tiempo excesivo y por tanto incumplir
los requisitos de interactividad.
- ¿Por
qué la manipulación directa de la entrada/salida ha de ejecutarse
en modo privilegiado?
Fundamentalmente,
para garantizar que el estado de la entrada/salida es siempre correcto y que se
respetan las políticas de acceso a los recursos definidas por el sistema
operativo. Si cualquier proceso pudiera acceder a la E/S directamente,
podría dejarla en un estado inconsistente. Podría saltarse las
prioridades de acceso a los recursos. En los dispositivos de almacenamiento o
transmisión de datos, se podría leer información no
autorizada. Por todo ello, el acceso directo a la E/S sólo se puede
hacer con las rutinas establecidas por el sistema operativo, en modo
privilegiado.
- ¿Por
qué es conveniente que el sistema operativo disponga de dos clases de
procesos: procesos pesados e hilos?
Si
los programadores pretenden escribir aplicaciones que contengan varios flujos
de ejecución concurrentes, éstos usarán el mismo
código y además necesitarán comunicarse información
con frecuencia. Por ello se considera apropiado definir una clase de procesos
que compartan código, datos y demás recursos dentro de una
aplicación: son los procesos ligeros o hilos. El proceso pesado es la
estructura que contiene uno o varios hilos, más los recursos compartidos
por estos hilos. Con ello se pueden escribir aplicaciones concurrentes con
menos consumo de memoria y menor tiempo de comunicación entre hilos (ya
que lo hacen a través de la memoria compartida).
- ¿Por
qué una duración muy baja del cuanto de tiempo en el algoritmo
Round-Robin
resulta perjudicial para el rendimiento del sistema?
Porque
cuanto más baja sea la duración del cuanto de tiempo, más
cambios de contexto se producirán por unidad de tiempo. Como el cambio
de contexto no realiza trabajo productivo, el rendimiento del procesador decae.
En particular, si el cuanto de tiempo es inferior a la duración de un
cambio de contexto, el procesador pasará más tiempo administrando
que realizando trabajo productivo.
Pregunta
3. Planificación de procesos.
Diagramas
de Gantt:
-
SRTF
0
|
1
|
2
|
3
|
4
|
5
|
6
|
7
|
8
|
9
|
10
|
11
|
12
|
13
|
14
|
15
|
P0
|
X
|
X
|
|
|
|
|
|
|
|
|
X
|
X
|
X
|
X
|
X
|
P1
|
|
|
X
|
X
|
|
X
|
X
|
|
|
|
|
|
|
|
|
P2
|
|
|
|
|
X
|
|
|
|
|
|
|
|
|
|
|
P3
|
|
|
|
|
|
|
|
X
|
X
|
X
|
|
|
|
|
|
-
Round-Robin, q=3
0
|
1
|
2
|
3
|
4
|
5
|
6
|
7
|
8
|
9
|
10
|
11
|
12
|
13
|
14
|
15
|
P0
|
X
|
X
|
X
|
|
|
|
X
|
X
|
X
|
|
|
|
|
|
X
|
P1
|
|
|
|
X
|
X
|
X
|
|
|
|
|
|
|
|
X
|
|
P2
|
|
|
|
|
|
|
|
|
|
X
|
|
|
|
|
|
P3
|
|
|
|
|
|
|
|
|
|
|
X
|
X
|
X
|
|
|
Hay
más cambios de contexto en el RR (seis) que en el SRTF (cinco).
El
menor tiempo de espera medio lo da el SRTF, como era de esperar, con
11/4=2’75 u.t. El RR da una media de 26/4=6’5 u.t.
La
decisión sobre cuál es el algoritmo más justo depende del
concepto que tengamos de “justicia”. En el ámbito de este
concepto pueden entrar: el reparto equilibrado del procesador, la igualdad de
oportunidades en el acceso al mismo, la menor desviación respecto a la
media de los tiempos de espera, etc.
|
SRTF
|
Round-Robin
|
P0
|
8
|
8
|
P1
|
1
|
8
|
P2
|
0
|
5
|
P3
|
2
|
5
|
Tiempos
de espera
|
Si
hablamos de igualdad en el trato, podemos observar que en el RR las
desviaciones respecto a la media en el tiempo de espera son menores (1’5
u.t. de diferencia) que en el SRTF, en el cual hay más disparidad de
resultados. Obsérvese la diferencia entre P0 y P2. Este dato es un
argumento a favor de calificar al RR como más justo.
Sin
embargo, la aparente justicia del RR no es tan clara. Comparado con el RR, el
SRTF no perjudica a ningún proceso, exceptuando quizás a P0, que
tiene un periodo de espera continua de 8 u.t. y que en el RR disfruta del
procesador con más frecuencia. Por el contrario, P1 y P2 están
muy penalizados en el RR. Como el SRTF beneficia a más procesos que el
RR, podría afirmarse que en este caso es más justo.
En
resumen, la respuesta es subjetiva y se considerará correcta si
argumentan su postura con suficiente solidez.
Pregunta
4. Solución a la sección crítica.
La
solución planteada no es válida, ya que no se cumple los
requisitos de progreso y de espera limitada. La condición de
exclusión mutua siempre se cumple, aunque aquí no hace falta
demostrarlo.
Si
los dos procesos intentan entrar al mismo tiempo en sección
crítica, se puede dar la siguiente secuencia de acciones (estado
inicial: P0 y P1 están en la línea 2):
Paso
|
Acción
|
Efecto
|
|
(p0,2)
|
flag[0]:=true
|
|
(p1,2)
|
flag[1]:=true
|
<aquí>
|
(p0,3)
|
flag[1]=true,
P0 entra en el while
|
|
(p1,3)
|
flag[0]=true,
P1 entra en el while
|
|
(p0,4)
|
flag[0]:=false
|
|
(p1,4)
|
flag[1]:=false
|
|
(p0,5)
|
como
flag[1]=false, P0 no entra en el while
|
|
(p1,5)
|
como
flag[0]=false, P1 no entra en el while
|
|
(p0,6)
|
flag[0]:=true
|
|
(p1,6)
|
flag[1]:=true
|
|
(p0,7)
|
P0
vuelve a la línea 3
|
|
(p1,7)
|
P1
vuelve a la línea 3
|
El
estado final es el mismo que en el punto marcado como <aquí>: los
dos booleanos están a true y tanto P0 como P1 están a punto de
ejecutar la línea 3. Esto quiere decir que se puede producir la misma
secuencia de acciones nuevamente, y así indefinidamente. Por tanto no se
garantiza que, si uno o varios procesos quieren entrar en sección
crítica, se tome una decisión en tiempo finito. Esto viola el
requisito llamado de progreso.
Por
otro lado, la condición de espera limitada tampoco se cumple, ya que un
proceso que acaba de salir de sección crítica puede volver a
entrar una y otra vez a pesar de que su compañero quiera también
entrar. Veamos esta secuencia, cuyo estado inicial es P0 en la línea 8 y
P1 en la línea 2:
|
Acción
|
Efecto
|
|
(p0,9)
|
flag[0]:=false,
P0 sale de sección crítica.
|
|
(p1,2)
|
flag[1]:=true,
P1 expresa su intención de entrar.
|
|
(p0,10)
|
P0
ejecuta su sección no crítica
|
|
(p0,2)
|
Flag[0]:=true,
P0 quiere entrar otra vez en s.c.
|
|
(p1,3)
|
P1
observa que flag[0]=true, entra en el bucle
|
|
(p1,4)
|
flag[1]:=false
|
|
(p0,3)
|
P0
observa que flag[0]=false: no entra en el bucle
|
|
(p0,7)
|
P0
sale del bucle
|
|
(p0,8)
|
P0
está en sección crítica
|
|
(p1,5)
|
P1
observa que flag[1]=true, sigue iterando
|
Esta
secuencia es posible y además se puede repetir indefinidamente, de forma
que no se garantiza que P1 entra en sección crítica en un tiempo
finito aunque P0 entra tantas veces como desea.
En
conclusión, el algoritmo propuesto no se puede considerar una
solución correcta al problema de la sección crítica.