FACULTAD DE INGENIERÍA EN SISTEMAS

LABORATORIO DE SISTEMAS OPERATIVOS

PERÍODO ACADÉMICO: 2023 – B EQUIPO:
PROFESOR: Ing. Rodrigo Chancusig MSc.
TIPO DE INSTRUMENTO: Guía de Laboratorio
TEMA: PLANIFICACIÓN DE PROCESOS
ÍNDICE DE CONTENIDOS
1. OBJETIVOS ...........................................................................................................................2
2. MARCO TEÓRICO .................................................................................................................2
Algoritmos de planificación ........................................................................................................2
3. PROCEDIMIENTO .................................................................................................................3
3.1 Instalación de CPU-OS Simulator ...................................................................................3
3.2 Código 1..........................................................................................................................3
3.3 Código 2..........................................................................................................................9
3.4 Código 3........................................................................................................................ 10
4. INFORME............................................................................................................................. 13

ÍNDICE DE FIGURAS
Figura 1. Ventana CPU Simulator..................................................................................................3
Figura 2. Compilador .....................................................................................................................4
Figura 3. Guardar los procesos .....................................................................................................4
Figura 4. Compilación de proceso .................................................................................................5
Figura 5. Carga de procesos en memoria......................................................................................5
Figura 6. Ventana de configuración ...............................................................................................6
Figura 7. Creación de cuatro estancias del proceso ......................................................................6
Figura 8. Simulación rápida ...........................................................................................................7
Figura 9. SJF-No preventivo ..........................................................................................................7
Figura 10. SJF preventivo .............................................................................................................8
Figura 11. Round Robin no preventivo ..........................................................................................8
Figura 12. Código 2 .......................................................................................................................9
Figura 13. Creación de instancias con lifetime...............................................................................9
Figura 14. Configuración RR ....................................................................................................... 10
Figura 15. View Log .................................................................................................................... 10
Figura 16. Código 3 ..................................................................................................................... 10
Figura 17. Configuración RR ....................................................................................................... 11
Figura 18. Pipeline ...................................................................................................................... 11
Figura 19. PCB ............................................................................................................................ 12
Figura 20. Configuración PCB ..................................................................................................... 12
 FACULTAD DE INGENIERÍA EN SISTEMAS

1. OBJETIVOS
1.1. Utilizar el simulador CPU Simulator para demostrar el funcionamiento de la
planificación de procesos.
1.2. Implementar diferentes algoritmos de planificación.

2. MARCO TEÓRICO
Algoritmos de planificación

Ante la necesidad de ordenar y controlar los procesos con el fin de ganar eficiencia
en la ejecución, los algoritmos de planificación son los encargados de dirigir los
procesos.

Conceptos básicos

1. Tiempo de espera: Es el tiempo que un proceso permanece en espera en la cola

antes de su ejecución.
2. Tiempo de retorno: Es el tiempo que trascurre desde que un proceso que empieza
su ejecución hasta que se termina de ejecutar.
3. Tiempo de respuesta: Es el tiempo que un proceso espera para ser ejecutado.
4. Uso de CPU: Es el porcentaje de tiempo que el programa ocupa el CPU
5. Productividad: Número de procesos que es ejecutarán en un tiempo determinado.

Algoritmos

1. FCFS (First-Come, First-Served). – También conocido como FIFO (First-In,

First-Out), es considerado el algoritmo de planificación más sencillo consiste
en que el primero en llegar es el primero es servirse. Tiene el funcionamiento
de un sistema de colas estricto, cuando un proceso pasa al estado en listo se
una a la cola y cuando este ya he haya ejecutado se selecciona el proceso que
ha estado más tiempo en la cola.
2. SJF (Shortest Job First). – También conocido como SPN (Shortest process
next) sigue el principio del primero el proceso con menor tiempo de ejecución
de esta forma el proceso más corto se colocará en la cabeza de la cola y se
ejecutará primero. El principal inconveniente que presenta este algoritmo es
que no se puede estimar el tiempo aproximado de ejecución de cada proceso.

3. RR (Round Robbin). – Conocido como uno de los algoritmos de planificación

más complejo para la implementación, este algoritmo trata a los procesos con
la misma prioridad y la principal característica es que es circular, es decir,
cuando termina el ejecutarse el último proceso se vuelve a ejecutar el primero
para el control a cada proceso se asigna un determinado intervalo de tiempo
llamad quantum.
 FACULTAD DE INGENIERÍA EN SISTEMAS

4. Se presentan varios casos para el control con el quantum:

• Proceso es menor al quantum: Cuando el termina antes el quantum se
planifica un nuevo proceso.
• Procesos es mayor al quantum: Cuando el quantum termina se expulsa
el proceso y se ejecuta el siguiente proceso de la lista, cuando se
terminan todos los procesos volverá al proceso expulsado y termina su
ejecución.
5. Apropiativo. – Este algoritmo permite la expulsión de procesos para poder
ejecutar otros procesos, colocando en la cola el proceso anterior.
6. No apropiativo. – Este algoritmo no permite la expulsión de procesos hasta
que termine su ejecución.

3. PROCEDIMIENTO
3.1 Instalación de CPU-OS Simulator

Descargar e instalar el simulador de:

https://teach-sim.com/downloads/

3.2 Código 1

Paso 1: Abrir CPU-OS simulator.

Figura 1. Ventana CPU Simulator

Paso 2: Elegir la opción “compiler”, esto deberá abrir una ventana emergente.
 FACULTAD DE INGENIERÍA EN SISTEMAS

Figura 2. Compilador

Paso 3. Colocar el código como el ejemplo de la figura en el Program Source y guardar como
P.txt

Figura 3. Guardar los procesos

Paso4. Compilar el programa.

 FACULTAD DE INGENIERÍA EN SISTEMAS

Figura 4. Compilación de proceso

Paso 5: Cargar los programas a memoria. Seleccionar la opción “load in memory”.

Figura 5. Carga de procesos en memoria

 FACULTAD DE INGENIERÍA EN SISTEMAS

Paso 6: Seleccionar la opción “OS Simulator”.

Figura 6. Ventana de configuración

Paso 7: Crear cuatro instancias del programa.

Doble clic cuatro veces sobre el nombre del programa en “Program list”, cuando se creen
las instancias del programa aparecerán en “READY PROCESSES (Ready Queue)”.

Figura 7. Creación de cuatro estancias del proceso

 FACULTAD DE INGENIERÍA EN SISTEMAS

Paso 8: Seleccionar la técnica FCFS en SCHEDULER → Policies.

Paso 9: Colocar “CPU speed” a su máxima velocidad en OS Control.

Figura 8. Simulación rápida

Paso 10: Observar y documentar el orden de ejecución de cada estancia y explicar el por
qué.

Paso 11: Seleccionar en el Planificador “Shortest Job First” con prioridad “Non-preemptive”

Figura 9. SJF-No preventivo

Paso 12: Crear tres instancias con prioridades 2,3 y 4 respectivamente

Paso 13: Seleccionar la velocidad de la CPU hasta la mitad
Paso 14: Seleccionar Start
Paso 15: Mientras se ejecuta la instancia 1 crear una cuarta instancia con prioridad 1.
Paso 16: Observar y documentar el orden de ejecución de cada estancia y explicar el por
qué.

Paso 17: Seleccionar en el Planificador “Shortest Job First” con prioridad “Preemptive”
 FACULTAD DE INGENIERÍA EN SISTEMAS

Figura 10. SJF preventivo

Paso 18: Repetir los pasos 12 al 15.

Paso 19: Observar y documentar el orden de ejecución de cada estancia y explicar el por
qué.

Paso 20. Seleccionar en el Planificador “Round-Robin” con prioridad “Non-preemptive”

Figura 11. Round Robin no preventivo

Paso 21: Crear cuatro instancias del programa con la misma prioridad 1 y CPU speed Slow.
Paso 22. Realizar un esquema de los estados de los procesos según lo observado en el
simulador.
 FACULTAD DE INGENIERÍA EN SISTEMAS

3.3 Código 2

Paso 1: Compilar y cargar en memoria el código mostrado en la figura 12.

Figura 12. Código 2

Paso 2: Crear tres instancias del proceso con “Lifetime” de 10, 32 y 6 segundos
respectivamente.

Figura 13. Creación de instancias con lifetime

 FACULTAD DE INGENIERÍA EN SISTEMAS

Paso 3. Seleccionar Round Robin, Non preemptive con 4 segundos como tiempo límite de
ejecución de cada proceso.

Figura 14. Configuración RR

Paso 4. Seleccionar velocidad Slow y presionar el botón “Start”.

Paso 5. Documentar lo observado en el log.

Figura 15. View Log

3.4 Código 3

Paso 1: Compilar y cargar en memoria el código mostrado en la figura 16.

Figura 16. Código 3

 FACULTAD DE INGENIERÍA EN SISTEMAS

Paso 2. Crear una instancia del código 2 y una instancia del código 3.

Paso 3. Seleccionar el algoritmo de planificación Round Robin, con prioridad “Non-

Preemptive”, el tiempo límite de ejecución de 10 ticks y mover el selector de velocidad a la
mitad como se aprecia en la Figura 17.

Figura 17. Configuración RR

Paso 4. Abrir la ventana del simulador del CPU, presionar el botón “Show Pipeline” y
asegurarse de que la casilla de “No instruction pipeline” esté marcada, según se visibiliza
en la Figura 18.

Figura 18. Pipeline

 FACULTAD DE INGENIERÍA EN SISTEMAS

Paso 5. Seleccionar Start, el primer proceso empezará a ejecutarse y cuando vuelva a estado
listo seleccionar Suspend.

Paso 6. Seleccionar el proceso del estado Listo y observar el valor del PCB como se muestra
en la figura 19.

Figura 19. PCB

Paso 7. Documentar el valor del registro PC y cerrar la ventana.

Paso 8. Marcar la casilla “Suspend on state change” que se encuentra en la sección de

“Running Processes”, luego se presiona el botón “Resume” para continuar la ejecución del
programa y se debe esperar hasta que el proceso se suspenda de manera automática, para
después visualizar el cambio de valor del PC. Basarse en figura 20.

Figura 20. Configuración PCB

Paso 9. Documentar 10 valores de PC tomados en cada suspensión para cada proceso.

 FACULTAD DE INGENIERÍA EN SISTEMAS

4. INFORME
• Resolver todo lo resaltado.

• A partir del siguiente código crear 5 procesos en los que varíe el límite del
lazo for:

PROGRAMA1 → 10
PROGRAMA2 → 20
PROGRAMA3 → 30
PROGRAMA4 → 40
PROGRAMA5 → 50

Para cada uno de los cinco escenarios a continuación dibujar el esquema de

planificación de los procesos, y determinar si se respetan o no las prioridades:

1. FCFS, programa1 y programa2, velocidad de CPU máxima.

2. SJF(non-preemptive), programa1 prioridad 3, programa 2 prioridad 2, programa
3 prioridad 4, programa 4 prioridad 3.
3. Round Robin (non-preemptive), quantum 10, programa1 prioridad 3, programa
2 prioridad 2, programa 3 prioridad 4, programa 4 prioridad 3.
4. Round Robin (preemptive), quantum 10, programa1 prioridad 3, programa 2
prioridad 2, programa 3 prioridad 4, programa 4 prioridad 3.
5. Round Robin (non-preemptive), quantum 10, programa1 prioridad 3, programa
2 prioridad 2, programa 3 prioridad 4, programa 4 prioridad 3. Mientras se ejecuta el
programa 2 añadir un nuevo proceso con prioridad 1.

5. CONCLUSIONES Y RECOMENDACIONES