untels 2018

1. UNIVERSIDAD NACIONAL TECNOLÓGICA DE LIMA SUR
FACULTAD DE INGENIERÍA Y GESTIÓN
Escuela Académico Profesional de Ingeniería de Sistemas
ALGORITMO ROUND-ROBIN
Trabajo presentado en cumplimiento
parcial de la materia de Sistemas
de Tiempo Real
Por
Cucho Suller, Elder Blaise
Pumahuare Ayala, Martin
Octubre de 2018

2. i
DEDICATORIA
Trabajo de investigación dedicado a nuestros padres que
supieron inculcarnos valores y principios, además por
ser el motor que nos impulsa a siempre superarnos.

3. ii
LISTA DE FIGURAS
Figura 1. Lista de Procesos preparados en Round-Robin.........................................................3
Figura 2. Ejemplo de tamaño del Cuanto.................................................................................5
Figura 3. Formula de Pasos de Ciclo........................................................................................5
Figura 4. Comparación entre FCFS y DRR..............................................................................8

4. iii
TABLA DE CONTENIDO
DEDICATORIA....................................................................................................................i
LISTA DE FIGURAS...........................................................................................................ii
CAPITULO I
INTRODUCCIÓN...............................................................................................................1
CAPITULO II
ALGORITMO ROUND-ROBIN.......................................................................................3
1.1. Tamaño del Cuanto..................................................................................................4
1.2. Aplicación Circular...................................................................................................5
1.2.1. Pasos de Ciclos..................................................................................................5
CAPITULO III
APLICACIÓN EN REDES ................................................................................................6
2.1. Weighted Round Robin (WRR)................................................................................7
2.1. Deficit Round Robin (DRR).....................................................................................7
CAPITULO IV
CONCLUSIONES...............................................................................................................9
REFERENCIA BIBLIOGRÁFICA...................................................................................10

5. 1
CAPITULO I
INTRODUCCIÓN
Los sistemasoperativosrealizanvariosprocesos, estos procesos se suelencomportar alternando
ráfagas de CPU y de E/S para lo cual realizan la planificación.
En la planificación tenemos el planificador (Scheduler) que es la parte del sistema operativo que
decide a que proceso preparado se le da paso a CPU. Existen distintos tipos de planificación
(Scheduling Algorithms):
 Planificación no apropiativa: Deja ejecutar al proceso en CPU hasta que este para por
bloqueo (inicio E/S) espera por otro proceso o terminación voluntaria.
 Planificación apropiativa: El planificador puede desalojar al proceso en CPU durante su
ejecución y cambiarlo por otro. Necesita una interrupción de reloj para poder ejecutarse
en periodos regulares de tiempo (quantum).
En los entornos interactivos (como los sistemas de tiempo compartido) el objetivo principal es
dar buenos tiempos de respuesta y, en general, compartir equitativamente los recursos del
sistema entre todos los usuarios. Por ello, sólo las planificaciones apropiativas se pueden
considerar en tales entornos y una de las más populares es la división en el tiempo en fracciones
o Round Robin.
Básicamente, eltiempode CPU se divideen fraccioneso quantum quese asignana los procesos.
Ningún proceso puede ejecutarse durante más de una fracción de tiempo habiendo procesos
esperando.
Puede ocurrir que:
 Un proceso necesite más de un quantum: El proceso pasará a la cola de procesos
preparados.
 Un proceso ceda el control de la CPU (por ejemplo, operación de E/S): Se planifica
otro proceso para que se ejecute.

6. 2
Cada proceso recibirá 1/N (siendo N el número de procesos preparados)del tiempo de la CPU.
Los procesos cortos tendrán buenos tiempos de respuesta (ya que se pueden ejecutar en un
único quantum de tiempo).
En general Round-Robin es un método para seleccionar todos los abstractos en un grupo de
manera equitativa y en un orden racional, normalmente comenzando por el primer elemento de
la lista hasta llegar al último y empezando de nuevo desde el primer elemento. El nombre del
algoritmo viene del principio de Round-Robin conocido de otros campos, donde cada persona
toma una parte de un algo compartido en cantidades, es decir, "toma turnos". En operaciones
computacionales, un método para ejecutar diferentes procesos de manera concurrente, para la
utilizaciónequitativadelosrecursosdel equipo, eslimitandocada proceso a un pequeño período
(quantum), y luego suspendiendo este proceso para dar oportunidad a otro proceso y así
sucesivamente. A esto se le denomina comúnmente como Planificación Round-Robin.

7. 3
CAPITULO II
ALGORITMO ROUND-ROBIN
Según (Cabalar, 2016), Es uno de los algoritmos de planificación más antiguos, sencillo y usado,
en este 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.
Específicamente cada proceso tiene asignado un intervalo de tiempo de ejecución, llamado
cuanto. Si el proceso agota su cuanto de tiempo, se elige a otro proceso para ocupar la CPU. Si
el proceso se bloquea o termina antes de agotar su cuanto también se alterna el uso de la CPU.
El Round-Robin es muy fácil de implementar. Todo lo que necesita el planificador es mantener
una lista de los procesos listos, como se muestra en la Figura 1. En esta figura en a) el proceso
P7 ocupa la CPU. En b) P7 se bloquea pasando P2 a ocupar la CPU. En c) P2 agota su cuanto
con lo que pasa al final de la lista y P4 ocupa la CPU.
Este algoritmo presupone la existencia de un reloj en el sistema para generar periódicamente
interrupciones al expirar el cuanto y proceder a llamar al dispatcher.
Figura 1. Lista de Procesos preparados en Round-Robin.

8. 4
1.1. Tamaño del Cuanto
Según (La Red Martinez, 2002), la determinacióndeltamañodelcuantoes vitalpara la operación
efectiva de un sistema de cómputo. Si el cuanto 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. Si el cuanto es muy pequeño, el gasto
extra por cambio de proceso se convierte en 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 cuanto 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 cuanto.
Por ejemplo, supongamos que el cambio de proceso tarda 5 mseg., y la duración del cuantum
es de 20 mseg. Con estos parámetros, se utiliza un mínimo del 20% del tiempo de la CPU en la
ejecución del sistema operativo. Para incrementar la utilización de la CPU por parte de los
procesos de usuario podríamos establecer un cuanto de 500 mseg., el tiempo desperdiciado con
este parámetro sería del 1%.
Pero consideremos lo que ocurriría si diez usuarios interactivos oprimieran la tecla enter casi al
mismo tiempo. Diez procesos se colocaríanen la lista de procesos listos. Sila CPU está inactiva,
el primero de los procesos comenzaría de inmediato, el segundo comenzaría medio segundo
después, etc. Partiendo de la hipótesis de que todos los procesos agoten su cuanto, el último
proceso deberá de esperar 4’5 seg. para poder ejecutarse. Esperar 4’5 seg. para la ejecución de
una orden sencilla como dir parece excesivo.
En conclusión, un cuanto corto disminuye el rendimiento de la CPU, mientras que un cuanto
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.

9. 5
Figura 2. Ejemplo de tamaño del Cuanto.
1.2. Aplicación Circular
Round-Robin es un algoritmo de planificación de procesos simple de implementar, dentro de
un sistema operativo se asigna a cada proceso una porción de tiempo equitativa y ordenada,
tratando a todos los procesos con la misma prioridad. En Sistemas operativos, la planificación
Round-robin da un tiempo máximo de uso de CPU a cada proceso, pasado el cual es desalojado
y retornado al estado de listo, la lista de procesos se planifica por FIFO, del inglés "First In,
First Out" (primero en entrar, primero en salir o primero llegado, primero atendido). (Cabalar,
2016)
1.2.1. Pasos de Ciclos
Para averiguar los pasos de ciclos de procesos totales se toman todos los números
de procesos y se calculan con los procesos necesarios para la realización de estos.
Figura 3. Formula de Pasos de Ciclo.

10. 6
CAPITULO III
APLICACIÓN EN REDES
Según (Cuéllar Quiñónez, 2009), la planificación Round Robin puede ser aplicada también a
otros problemas de planificación, como la planificación de redes. En las redes inalámbricas,
donde varios servidores comparten un mismo canal, este algoritmo provee a cada servidor un
intervalo regular de tiempo para transmitir o recibir información mediante el canal compartido.
Esto hace parecer a Round Robin como un algoritmo justo, pero, de todos modos, por ser
mucho menos eficiente que el "algoritmo de proporcionalidad justa", es muy difícil proveer un
buen servicio a los suscriptores. El operador de la red también sufrirá capacidad reducida en la
red. La causa principal es que este algoritmo no tiene en cuenta el cambio de condiciones de
recepción en los diferentes receptores, por lo que planeará transmisiones desde/hacia los
suscriptores de la mitad de tiempo cuando sus condiciones de recepción sean peores que las
habituales. En contraste, el planeamiento de proporcionalidad justa tendrá en cuenta el cambio
de condiciones de recepción en los diferentes receptores y agendará las transmisiones
desde/hacia los suscriptores cada vez que las condiciones de recepción estén peores que lo
normal.
Los algoritmos de planificación basados en Round-Robin, asignan una ranura de tiempo (time
slot) a cada flujo, y el envío de paquetes se hace de manera alternada, flujo por flujo, en una
secuencia. Porejemplo, si se tuvieran3 colas(Q1, Q2 y Q3) a cada una se le asignaría una ranura
de tiempode duración t1. El algoritmoempezaría a enviarlospaquetesdeQ1 duranteun tiempo
t de duración t1, después enviaría paquetes de Q2 en un tiempo t1 y posteriormente enviaría
paquetes de Q3 en t1, para nuevamente retornar a la cola Q1 para el envío de paquetes.
Este tipo de algoritmo es mucho más fácil de implementar en redes, pero tiene una respuesta
muy pobre con respecto al retraso obtenido para cada paquete. Se documentará el
funcionamiento de los principales algoritmos que funcionan con este esquema para
posteriormente, en la siguiente sección, estudiar los algoritmos híbridos que permiten mejorar
lascaracterísticasdedesempeñoalutilizarcomponentesde los algoritmosbasadosen timestamp
(marca de tiempo) y Round-Robin.

11. 7
2.1. Weighted Round Robin (WRR)
(Cuéllar Quiñónez, 2009) Dice que este algoritmo es una modificación del Round-Robin, en el
cual solo se envía un paquete por cola en cada turno de servicio. A cada flujo se le asigna un
peso que corresponde a un porcentaje del ancho de banda del enlace que utilizará. El número
de paquetes a enviar en cada turno se calcula con base en el peso del flujo y en la capacidad del
enlace.
WRR funciona bien para el envío de paquetes de tamaño fijo, pero presenta problemas de
desempeño cuando los paquetes son de longitud variable, ya que en el caso de paquetes de
tamaño mayor utiliza más ancho de banda del asignado, lo cual hace que el desempeño en el
envío de paquetes de las otras colas disminuya.
2.1. Deficit Round Robin (DRR)
Este algoritmo mejora los inconvenientes que presenta el WRR y permite así enviar paquetes de
longitud variable con un mejor desempeño. Funciona en dos variables, una llamada quantum
que indica la cantidad de bits a enviar en cada turno de transmisión y otra llamada contador de
déficit (deficit counter) que se encarga de almacenar el valor del quantum obtenido al transmitir
un paquete y que permitirá posteriormente enviar paquetes de longitud variable.
El algoritmoempiezasufuncionamientoenviandopaquetesde lascolas que tenganpaquetespor
mandar.Si el tamaño del paquete esmenoro igual al valor del quantum, se envía.Sinembargo,si
la longitud del paquete es mayor que el valor del quantum, el paquete debe esperar a ser
transmitidoenotroturno.En este caso el deficitcounterse inicializaparaestacola y si el paquete
no puede ser enviado en un turno, el deficit counter es incrementado en el valor que posea el
quantum.Cuandoel deficitcounteresigualomayoral tamañodel paquete (enelcasode paquetes

12. 8
mayores que el valor del quantum) se envía el paquete y el deficit counter vuelve a cero (Cuéllar
Quiñónez, 2009).
En la Figura3 se puede apreciarla comparación entre una cola que trabaja con FCFS y otra que lo
hace con el esquema de DRR.
Figura 4. Comparación entre FCFS y DRR.

13. 9
CAPITULO IV
CONCLUSIONES
Round-Robin es uno de los algoritmos de planificació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 cuanto o Quantum para la
operación efectiva de un sistema de cómputo. Ya que si:
 El cuanto 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 cuanto es muy pequeño, el gasto extra por cambio de proceso se convierte en 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 cuanto 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 cuanto. En resumen,
tenemos: un cuanto corto disminuye el rendimiento de la CPU, mientras que un cuanto 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 un mismo canal, estealgoritmoprovee a cada servidorun intervalo regular detiempo
para transmitir o recibir información mediante el canal compartido.

14. 10
REFERENCIA BIBLIOGRÁFICA
Cabalar, P. (2016). Sistemas Operativos. Procesos. Coruña, España. Recuperado el 8 de Octubre
de 2018, de http://www.dc.fi.udc.es/~so-grado/SO-Procesos-planif.pdf
Cuéllar Quiñónez, J. C. (Julio-Diciembre de 2009). Algoritmos de planificación en redes de
paquetes. Vol. 7. Cali, Colombia: Sistemas & Telemática. Recuperado el 8 de Octubre
de 2018, de http://www.redalyc.org/pdf/4115/411534381006.pdf
La Red Martinez, D. L. (2002). Book Google. Argentina. Recuperado el 8 de Octubre de 2018,
de
https://books.google.com.pe/books?hl=es&lr=&id=N5yxiwilBhoC&oi=fnd&pg=P
R1&dq=sistemas+operativos+la+red+martinez&ots=02Q4LvF3EY&sig=NayPj01qh
VmKEFKZIG0quB_kk-
M#v=onepage&q=sistemas%20operativos%20la%20red%20martinez&f=false
Miranda Gómez, O., & Mejía Alvarez, P. (2003). Kernel de Tiempo Real para Control de
Procesos. Planificación por turno rotatorio (Round Robin). D.F., México: CINVESTAV-
IPN. Recuperado el 8 de Octubre de 2018, de
http://delta.cs.cinvestav.mx/~pmalvarez/miranda-mejia.pdf
Sistemas operativos Windows y Unix/Linux. (s.f.). Algoritmos de Planificación. Planificación por
Turno Rotatorio (Round-Robin). Recuperado el 8 de Octubre de 2018, de
http://www.juntadeandalucia.es/empleo/recursos/material_didactico/especialidades/
materialdidactico_administrador_servidores/Content/1-so/1-
AnexoAlgoritmosPlanificacion.pdf