Examen final de Sistemas Operativos I 10 de diciembre de 2003

E. U. de Informática
Departamento de Informática Aplicada
Examen Final de Sistemas Operativos I
10 de diciembre de 2003
EJERCICIO 2 (3,5 puntos)
Tiempo: 60 m
En un sistema de tiempo compartido monoprocesador, se pretende utilizar un algoritmo de planificación expulsor
conocido como algoritmo de “la lotería”, cuyo funcionamiento se describe a continuación: cuando se crea un
proceso se le asigna un número de papeletas en blanco. La cola de procesos preparados está ordenada por orden
decreciente de papeletas asignadas. Por ejemplo, si hay 3 procesos preparados P1, P2 y P3, que cuentan
respectivamente con 3, 1 y 5 papeletas, estarán ordenados en la cola como P3, P1 y P2. Cuando hay que elegir un
nuevo proceso a planificar, el sistema realiza un sorteo generando un número aleatorio entre 1 y el número total de
papeletas repartidas.
papeletas
P3
P1
P2
Tras el sorteo, encontraremos al ganador si contamos papeletas desde el principio de la cola de preparados. Por
ejemplo, si sale ganadora la papeleta séptima, el ganador será el proceso P1.
El proceso ganador tomará control de la CPU hasta que se bloquee voluntariamente o el sistema le expulse porque
haya consumido una porción de tiempo preestablecida. El sorteo se repite siempre que haya que elegir un nuevo
proceso a planificar, teniendo en cuenta que, en cada sorteo, el número de procesos preparados puede ser distinto y
por tanto, el número total de papeletas a considerar también.
Supuesto que el sistema operativo cuenta con las siguientes estructuras para la gestión de procesos:
typedef int idProceso;
typedef struct colaProcesos {
idProceso primero;
idProceso ultimo;
} colaProcesos_t;
typedef struct descriptor {
idProceso pid;
/* Identificador del proceso */
idProceso siguiente; /* Para implementar colas de procesos */
----/* Resto de campos */
} descriptor_t;
descriptor_t
idProceso
colaProcesos
colaProcesos
tablaDescriptores [maxProcesos];
enEjecucion;
preparados;
enEspera;
SE PIDE:
1. Indicar cómo se puede reducir dinámicamente la posibilidad de inanición de un proceso.
2. Indicar qué nuevas estructuras de datos y/o modificaciones a las ya existentes son necesarias para soportar
este algoritmo de planificación.
3. Para que un proceso recién creado pueda participar en el sorteo siguiente, indicar las acciones a realizar en
la llamada al sistema idProceso crearProceso(int numPapeletas).
4. Implementar la función idProceso procesoGanador(). La función idPapeleta Sorteo(totPapeletas)
solo se encarga de devolver un número aleatorio entre 1 y el total de papeletas repartidas (totPapeletas)
entre los procesos preparados en el momento de realizar dicho sorteo.
5. Indicar qué acciones hay que tomar, con respecto a este algoritmo, cuando un proceso se bloquea
voluntariamente.
E.U. de Informática
Departamento de Informática Aplicada
Examen final de Sistemas Operativos I
EJERCICIO 2 (puntuación 3´5 puntos) Solución
10 de diciembre de 2003
Tiempo Estimado 60 m
1. Indicar cómo se puede reducir dinámicamente la posibilidad de inanición de un proceso.
Asignándole más papeletas, ya que cuantas más tenga, más probabilidad tendrá de ganar. Por ejemplo, se podría
utilizar la técnica del envejecimiento para ir aumentado el número de papeletas de los procesos de la cola de
preparados.
2. Indicar qué nuevas estructuras de datos y/o modificaciones a las ya existentes son necesarias para
soportar este algoritmo de planificación.
int numPapeletasTotales;
idProceso procesoGanador;
/* Papeletas repartidas entre los preparados */
/* Proceso que tiene la papeleta */
Para cada descriptor de proceso, hay que añadir el siguiente campo:
int numPapeletas;
/* Número de papeletas asignadas a cada proceso*/
3. Para que un proceso recién creado pueda participar en el sorteo siguiente, indicar las acciones a realizar
en la llamada al sistema idProceso crearProceso(int numPapeletas).
 Al crear un proceso, habría que guardar el número de papeletas asignadas en su campo:
tablaDescriptores[proceso].numPapeletas = numPapeletas;

También habría que incrementar el número de papeletas del sistema:
numPapeletasTotales = numPapeletasTotales + numPapeletas;

Y por último, reordenar la lista de preparados en orden decreciente de papeletas.
función idProceso
procesoGanador(),
considerando que idPapeleta
solo se encarga de devolver un número aleatorio entre 1 y el total de papeletas
repartidas entre los procesos preparados en el momento de realizar dicho sorteo.
4. Implementar
la
Sorteo(totPapeletas)
idProceso Ganador(){
int suma = 0;
int papeletaGanadora;
idProceso proceso = preparados.primero;
/* se usa la cola de preparados */
papeletaGanadora = Sorteo(numPapeletasTotales);
/* se realiza el sorteo */
while ( suma < papeletaGanadora) {
/* ¿quién tiene la papeleta? */
suma = suma + tablaDescriptores[proceso].numPapeletas;
if (suma < papeletaGanadora)
proceso = tablaDescriptores[proceso].siguiente;
}
return idProceso
/* Este proceso es el ganador */
}
Se saca el proceso ganador de la cola de preparados, se decrementa el número de papeletas que tiene asignadas
del total.
numPapeletasTotales = numPapeletasTotales - tablaDescriptores[proceso].numPapeletas;
5. Indicar qué acciones hay que tomar, para que este algoritmo siga funcionando correctamente, cuando un
proceso se bloquea voluntariamente.
No hay que realizar ninguna acción, ya que cada vez que el proceso toma control de la cpu, se le saca de la cola
de preparados y se actualiza el total de papeletas, por lo que si se bloquea, ya no participa en los siguientes
sorteos. Cuando despierte, para que participe de nuevo en el sorteo, se le incluirá en la cola de preparados y se
incrementará el total de papeletas con las papeletas que tenía asignadas.
Otra implementación podría considerar una cola de procesos ejecutables (preparados + el proceso en ejecución),
de tal forma que, solo cuando un proceso se bloquea, se decrementa su número de papeletas asignadas del total
y se le elimina de la cola de procesos ejecutables. Esta variante intenta reducir la sobrecarga de la modificación
del total de papeletas y de la gestión de la cola de preparados cada vez que un proceso toma o cede el control de
la cpu. Sin embargo, este implementación tendría problemas si se utilizase con sistemas multiprocesador, ya que
podría salir ganador un proceso que ya esta en ejecución.