UNIVERSIDAD DE LA COSTA CUC

ALGORITMO DE PLANIFICACIÓN DE PROCESOS Y SIMULADOR

HECHO POR:

LAURA VANESSA OJEDA MÉNDEZ

JOISER ANDRÉS JIMENEZ BARRETO

ANDRÉS JOSÉ RODRIGUEZ PÉREZ

PROFESORA KELLY CORONOADO

SISTEMAS OPERATIVOS

GRUPO AN

2019
Introducción

Este trabajo consta de una investigación acerca de las características propias del algoritmo de
planificación conocido como Round Robin en un sistema monoprocesador. La planificación de un
procesador es una de las partes más importantes dentro del análisis de un sistema operativo. Vale
la pena aclarar para aquellos que no estén tan introducidos en el tema, que la planificación de un
procesador es la base de los sistemas operativos para la multiprogramación. El concepto de
multiprogramación es: teniendo un número de programas en memoria al mismo tiempo, la CPU
puede ser compartida entre ellos, haciendo más trabajos en menor tiempo. La planificación del
procesador es implementar algoritmos que le permitan decidir al sistema operativo que procesos
van a competir por el uso de la CPU, y al “despachador”, que proceso va a hacer uso de ella en cada
instante; y también la manera o técnicas que se usan para decidir cuanto tiempo de ejecución se le
asigna a cada proceso.

El Round Robin es un algoritmo de los más conocidos dentro de los algoritmos de planificación, y de
los más usados también. Consta básicamente de la asignación de un quantum a cada proceso, como
tiempo máximo de uso del procesador. nos proponemos con este trabajo evaluar la eficiencia del
Round Robin con respecto a los objetivos de la planificación, si cumple o no con estos, y si una vez
implementado puede llegar a tener deficiencias.

Investigación: Algoritmo Round Robin

El round Robin es uno de los algoritmos más antiguos, sencillos y equitativos en el reparto de la CPU,
lo que significa que evita que sea monopolizado el uso de la CPU. Esto es muy válido para entornos
de tiempo compartido.

¿En qué consiste?

El algoritmo consiste en definir una pequeña unidad de tiempo llamada quantum, la cual se le asigna
a cada proceso que tiene como estado “listo”. Si el proceso agota su “quantum” de tiempo, se elige
otro proceso para que ocupe la CPU. De igual manera si el proceso se bloquea o finaliza antes de
agotar su quantum, también alterna el uso de la CPU.

Es por esto que la necesidad de un reloj del sistema existe. Este dispositivo genera interrupciones
periódicamente. Estas son muy importantes, pues garantiza que el sistema operativo obtenga el
mando de la CPU periódicamente. El quantum de un proceso equivale a un número fijo de ciclos del
reloj. Al ocurrir una interrupción del reloj que coincide con el término del quantum se llama
despachador, el cual le cede el control de la CPU al proceso seleccionado por el planificador. Este
algoritmo es usado para ayudar a crear procesos o trabajos programados para asegurar que cada
proceso requerido para realizar una acción tiene suficiente tiempo para ejecutarlo.” Por ejemplo,
en un ordenador el usuario empieza tres aplicaciones, que pueden ser la aplicación de correo, el
navegador Web y un procesador de texto. Estas aplicaciones son cargadas en el sistema de memoria,
y cada uno de ellos puede funcionar de forma transparente para el usuario. Round Robin se encarga
de compartir los recursos entre las tres aplicaciones y sus procesos (y muchas otras que están
funcionando de forma invisible para el usuario). Esta forma de manejar los procesos funciona bien
porque cada aplicación consigue una cierta cantidad de tiempo por cada proceso cíclico. Un proceso
cíclico es la cantidad de tiempo que le lleva a la CPU gestionar cada proceso el mismo tiempo.”
Su diseño

El algoritmo de planificación round-Robin fue especialmente diseñado para sistemas en tiempo

compartido. Se define una pequeña unidad de tiempo común llamada quantum de tiempo o time
slice, que generalmente tiene un valor entre 10 y 100 milisegundos. La cola de listos se trata como
una cola circular. El planificador de CPU recorre la cola asignando el procesador a cada proceso
durante un intervalo de tiempo de hasta un quantum.

Para implementar la planificación RR, la cola se mantiene como una cola de procesos FIFO. El
planificador de la CPU selecciona el primer proceso de la cola, y únicamente puede salir del estado
de ejecución por tres motivos: que termine su ejecución, se proceda a la llamada a una E/S y el
proceso se quede bloqueado o que se genere una interrupción por haber superado un quantum de
ejecución del proceso.

Simulador Round Robin:

Este simulador fue desarrollado en el lenguaje de programación JAVA. Para realizar este simulador,
primero, creamos 3 paquetes: Recursos: para las imágenes utilizadas en los botones; UI: para el
formulario a utilizar; SilumadorRoundRobin: donde se guardan las clases. En el paquete
“simuladorRoundRobin” creamos 3 clases: gráfica, procesos y simulador. Ver figura 1.

Clases:

 Gráfica: esta clase se creó con el objetivo de poder dibujar la simulación del proceso en una
gráfica de barras apiladas. Para poder realizar esta gráfica utilizamos la librería JFreeChart.
Ver figura 2
 Procesos: esta clase guarda el objeto proceso con los datos requeridos: PID, nombre del
proceso, tiempo de llegada, tiempo de ráfaga y prioridad. Además, se usan otras variables
para guardar el tiempo de espera, tiempo de retorno y para poder realizar el proceso.
 Simulador Round Robin: aquí creamos varios métodos para agregar, eliminar procesos,
ordenar los procesos en FIFO y para realizar el proceso principal el algoritmo round robin.
Figura 1. Paquetes y clases del proyecto en JAVA Figura 2. Librería utilizada JFreeChart

Clase Procesos:

Contiene 3 constructores: el constructor normal, uno para poder graficar la simulación y otro para
realizar operaciones con los procesos. Declaramos las variables principales: PID, nombre del
proceso, tiempo de llegada y demora y prioridad. Las demás variables se utilizan para graficar.
También, se encuentran los getters y setters de cada variable.
Figura 3. Clase Procesos
Figura 4. Clase procesos
Clase simuladorRoundRobin:

Como se puede observar en la figura 5, declaramos 4 ArrayList: 3 tipo Proceso para realizar la
simulación, un auxiliar para las operaciones y uno en donde se guardan los datos para la gráfica. El
otro ArrayList es tipo String en donde se guardan los nombres de los procesos para luego colocarlo
en la gráfica.

Figura 5. Clase simuladorRoundRobin

Métodos:

 estaVacía(): devuelve en booleano si el ArrayList está vacía

 existeProceso(): verifica si el proceso existe comparando el nombre del proceso actual con
los demás procesos.

 agregarProceso(): se verifica si el proceso existe, si no existe se agrega el proceso a la lista.

Además, se crea un proceso auxiliar en donde se agrega solamente el nombre del proceso
y el tiempo de demora (ráfaga). Este se guarda en la lista auxiliar. Esto se hace para
guardar el tiempo de demora.

 ordenarPorLlegada(): se ordenan los procesos según el tiempo de llegada. En el primer for

se guardan los nombres en orden de llegada de cada proceso para luego ser utilizado para
graficar. Se declara dos ArrayList de tipo Proceso auxiliares. Utilizamos un while, en el cual
mientras el tamaño del ArrayList aux2 sea diferente al tamaño del ArrayList principal, en
una variable int la igualamos al proceso menor, método explicado más adelante, del
Arraylist auxiliar que tiene los mismos datos que el principal. Añadimos en el auxiliar2 el
proceso menor y lo eliminamos del auxiliar. Se realiza repetitivamente hasta el ultimo
proceso. Limpiamos el ArrayList principal y añadimos los procesos ordenadamente.
 procesoMenor(): a partir del ArrayList proceso, se declaran dos variables int. En una
guardamos el tiempo de llegada del primer proceso y en otra la dejamos en cero. Se realiza
un for según el tamaño del ArrayList, en este se compara si el tiempo de llegada del proceso
según el for es menor al proceso menor actual, si lo es se establece como el menor. Este
método devuelve el número en donde se encuentra el proceso menor.

 eliminarProceso(): según el nombre del proceso se elimina. Para los dos for se compara si el
nombre del proceso es el mismo y se remueve de las listas. Una lista es la principal y otra
contiene el tiempo de demora.

 getRetorno(): devuelve el retorno del proceso

 limpiar(): limpia todos los ArrayList

 modificarTiempoFIn(): se utiliza para modificar el tiempo final en la lista para la gráfica, ya
que al momento en que se crea la lista no se sabe el tiempo en el que termina el estado de
espera. Se compara los nombres, el estado de las listas y si el tiempo final es igual a cero,
entonces se modifica por el tiempo actual.

 getGrafica(): devuelve el ArrayList tipo procesos de la gráfica.

 getNombresOrdenados(): devuelve el ArrayList tipo String con los nombres de los procesos
ordenados según el tiempo de llegada

 roundRobin(): este es el método principal en donde se simula el algoritmo Round Robin. Se

declaran dos ArrayList tipo procesos, un String, 4 int y un booleano. El int numeroProcesos
es igual al tamaño de la lista principal proceso. Mientras que numeroProcesos sea mayor a
cero, entonces realiza las siguientes operaciones: en la variable String se va guardando el
tiempo e información sobre el proceso. Primero comparamos que el tamaño del proceso
sea mayor al número de procesos que inicia en cero y que el tiempo sea mayor o igual al
tiempo de llegada del proceso actual. Si es verdadero, se guarda en el String el tiempo en
que se atiende el proceso. Se agrega el proceso actual a la lista de procesos cola, en el cual
se guardan los procesos a ejecutar, y el número de procesos aumenta. Si no se cumple la
condición se aplica otra condición en donde el numero de procesos es mayor a cero o el
tamaño del proceso cola es mayor a cero, si no se cumple aumenta el tiempo, pero si se
cumple entonces miramos si la lista auxiliar está vacía, se ingresa el primer proceso de la
lista proceso cola y se elimina de esta. Se establece el auxiliar booleano verdadero y se
guarda la información sobre el proceso en el String. Si la lista auxiliar no esta vacía, se
verifica que el booleano auxiliar sea verdadero y si lo es se comprueba que el tiempo de
demora del primer proceso de la lista auxiliar sea mayor o igual al quantum, si lo es se
establece el nuevo tiempo de demora restando el tiempo de demora actual menos el
quantum, se aumenta el tiempo según el quantum, se guardan los datos para la grafica en
la lista gráfica, siendo este el estado de ejecución, se crea un nuevo proceso con el nombre
del proceso actual, el tiempo de inicio del estado y el tiempo fin, el estado de espera se
identifica por el número 1, y se toma el identificador del proceso actual. Además, se guarda
la información sobre el proceso en el String. Si no se cumple la condición quiere decir que
el tiempo de demora es menor a quantum por lo tanto, el tiempo aumenta según el tiempo
de demora, se guarda en el String la información, se crea un nuevo dato en la lista grafica y
se modifica el tiempo de demora del proceso actual que sería cero, ya que se ejecutó
completamente. Luego, se tiene una condición en el que el tiempo de demora es menor a
1, si se cumple primero buscamos el tiempo de demora inicial del proceso actual
comparando el nombre con los datos de la lista auxiliar, hecha en agregarProceso(). Se
guarda la información en el String y se modifica el tiempo de espera, retorno y fin,
calculando según las fórmulas. El número de procesos se resta y se elimina el proceso de la
lista auxiliar. Si no se cumple la condición se establece el booleano auxiliar como falso. Y
según la condición anterior, si el booleano no es verdadero, entonces agregamos el proceso
que eta en la lista auxiliar a la lista cola para ser atendido más tarde, se guarda la
información en el String, se crea un nuevo dato para la lista grafica cambiando que ahora el
estado es de espera y se elimina el proceso de la lista auxiliar. Este método devuelve un
String con la información del proceso detalladamente.
  Datos(): este método devuelve un String con los datos adicionales a la simulación: el tiempo
de espera de cada proceso, tiempo de retorno de cada proceso y el total de tiempo de estas
dos entre los procesos.

Clase gráfica:

Esta clase tiene dos variables String que son los estados: espera y ejecución. Para graficar utilizamos
la librería JFreeChart, a partir de este creamos las variables para el grafico, el axis en Y y en X.
Creamos 5 métodos, como se puede visualizar en la figura 6.

Figura 6. Clase gráfica

 Constructor Grafica(): Se pide un ArrayList de tipo procesos y uno de tipo String. El de String
son los nombres que se obtiene de la clase simuladorRoundRobin y el tipo proceso se
obtienen los valores para graficar. En el chart se crearía la gráfica.

 getGrafico(): devuelve el grafico

 initData(): se guardan los nombres de los procesos para ser utilizados como el axis x, según
la lista brindada.

 crearIntervalosGrafica(): Se establecen los colores de cada estado y los axis de la gráfica (x,
y)

 crearXYIntervalosDataSet(): Se establecen los valores de los intervalos según el estado

(espera o ejecución)
Formulario para la simulación:

Este formulario contiene 3 secciones Round robin donde se agrega la información del proceso, se
modifica, elimina y ejecuta, como se puede ver en la figura 7. En el lado detalles, se encuentra
información detallada del proceso y la gráfica del proceso, como se observa en la figura 8. Y en el
lado acerca de, se encuentra la información sobre los integrantes, ver figura 9.

Figura 7. Formulario
Figura 8. Formulario lado “detalles”.

Figura 9. Formulario lado “Acerca de”

Operaciones con los botones:

 Botón agregar: Se valida que los campos tengan información y se agrega a la tabla el dato

 montarDatos(): se suben los datos a la tabla

 Botón eliminar: se elimina la fila seleccionada

 Botón ejecutar: se verifica si los datos ingresados tienen tiempo de demora en cero, si no
tiene entonces se agrega cada proceso a la lista de procesos, se ordena por llegada y se
ejecuta el round robin. Se establece el valor de retorno en la tabla por el obtenido en la
ejecución y el de demora como cero. Además, se grafica

 Botón editar: se modifica el proceso

 Botón limpiar: limpia la tabla, los textArea y demás

 Ejecutar gráfica: dibuja la gráfica en un panel

 Agregar datos e igual a cero: El primero añade los procesos de la tabla en la lista principal y
el segundo verifica que en la tabla no haya ceros en el tiempo de demora
Conclusión:

La conclusión que podemos sacar lo expresado, podemos resumirla de la siguiente manera: La

planificación es una de las áreas del desarrollo de un sistema operativo de más relevancia, ya que
de ella depende en gran medida la performance de este. Notamos que, en sistemas más complejos,
como los de tiempo real , la planificación correcta es sumamente importante, considerando que
estos son usados para controlar, en su mayoría, sucesos de la vida real y no cumplirían su cometido
si fallan por tener una planificación de procesos deficiente que provoque lentitud o “cuelgues”

Round-Robin es uno de los algoritmos de lanificación más antiguos, sencillo y usado, en este se
considera que cada proceso tiene asignado un intervalo de tiempo de ejecución llamado Quantum.
Round-Robin es muy sencillo de implementar, todo lo que necesita el planificador es conocer la cola
de los procesos listos y una vez que el proceso en ejecución consume su Quantum, se le quita el
procesador y se le asigna al siguiente en la cola, colocando al proceso que salió al final de la cola de
procesos listos.

En este algoritmo es importante la determinación del tamaño del Quantum para la operación
efectiva de un sistema de cómputo. Ya que si:

• El Quantum de tiempo es muy grande, cada proceso tendrá el tiempo necesario para
terminar, de manera que el esquema de planificación por turno degenera en uno de primero-en-
entrar-primero-en-salir (FIFO).

• El quantum es muy pequeño, el gasto extra por cambio de proceso se convierte el el factor
dominante y el rendimiento del sistema se degradará hasta el punto en que la mayor parte del
tiempo se invierte en la conmutación del procesador, con muy poco o ningún tiempo para ejecutar
los programas de los usuarios.

El tamaño del quantum debe fijarse en el tamaño lo bastante grande como para que la mayoría de
las peticiones interactivas requieran menos tiempo que la duración del quantum. En resumen,
tenemos: un quantum corto disminuye el rendimiento de la CPU, mientras que un quantum muy
largo empobrece los tiempos de respuesta y degenera en el algoritmo FIFO. La solución es adoptar
un término medio como 100 mseg.

El algoritmo Round-Robin puede ser aplicada también a otros problemas de planificación, como la
planificación de redes, ya que, en las redes inalámbricas, donde varios servidores comparten el
mismo canal, este algoritmo provee a cada servidor un intervalo regular de tiempo para transmitir
o recibir información mediante el canal compartido.

Referencias

[1] Anonimo, «Roun Robin,» [En línea]. Available:

https://www.udg.co.cu/cmap/sistemas_operativos/planificacion_cpu/round_robin/Round%20Robin.html.

[2] «Ordenadores y portatiles,» [En línea]. Available: http://www.ordenadores-y-portatiles.com/round-

robin.html.
[3] E. Blaise, «SlidesShare,» [En línea]. Available: https://es.slideshare.net/salvadorvp32/round-robin-apa.

[4] Anonimo, «Wikipedia,» [En línea]. Available: https://es.wikipedia.org/wiki/Planificaci%C3%B3n_Round-

robin.