UNIVERSIDAD NACIONAL DE INGENIERÍA

FACULTAD DE INGENIERÍA INDUSTRIAL Y DE SISTEMAS

SISTEMAS OPERATIVOS – ST324

ENTREGABLE TRABAJO FINAL

INFORME: “GESTIÓN DE PROCESOS, MEMORIA Y
DISPOSITIVOS DE ENTRADA Y SALIDA”
Grupo N° “1”
Nro. Código Apellidos y Nombres Nota Letras
1 20142069E CAHUANA ALCANTARA KEILA
REBECA
2 20140227B COLAN SULLON RUBEN DARIO

3 20144152G GARCIA LOPEZ ANDY FREDY

4 20142568A RUEDA FERNANDEZ GEISSON
LELIS

PROFESOR: RAMOS MONTES, CARLOS

FECHA DE ENTREGA: 12/12/2018

2018 – II

pág. 1
 Índice

Contenido
1. RESUMEN .............................................................................................................................................. 4
2. Introducción ............................................................................................................................................ 5
3. Objetivos .................................................................................................................................................. 6
3.1. Objetivos Generales .................................................................................................................................. 6
3.2. Objetivos específicos ................................................................................................................................ 6
4. DESCRIPCIÓN DEL TRABAJO. ....................................................................................................... 7
4.1. ANTECEDENTES Y MARCO TEÓRICO .............................................................................................. 7
4.1.1. Gestión de procesos .......................................................................................................................... 7
4.1.2. Estados de un proceso ....................................................................................................................... 7
4.1.3. Definición de estados ........................................................................................................................ 8
4.1.4. Planificación de un proceso .............................................................................................................. 9
4.1.5. Políticas de planificación de procesos ............................................................................................ 10
4.1.6. Casos de administración de procesos .............................................................................................. 10
UNIX .............................................................................................................................................................. 11
Windows ......................................................................................................................................................... 11
4.2. Interrupciones ....................................................................................................................................... 13
4.2.1. Ciclo de reconocimiento de interrupción ........................................................................................ 13
4.2.2. Gestión de entrada y salida E/S....................................................................................................... 14
4.2.3. Manejo de Interrupciones en Windows NT .................................................................................... 15
4.3.Gestión de memoria ................................................................................................................................ 17
4.3.1 Memoria .......................................................................................................................................... 17
4.3.1.1 Estrategias de asignación ................................................................................................................ 18
4.3.1.2 Fragmentación de la memoria: ........................................................................................................ 19
4.3.2.2 Protección de la memoria................................................................................................................ 19
4.3.1.4 Swapping ........................................................................................................................................ 20
4.3.1.4 Memoria virtual .............................................................................................................................. 21
4.3.2.1 Paginación ....................................................................................................................................... 23
4.3.2.2 Direccionamiento de paginación..................................................................................................... 24
4.4 Arquitectura del Software prototipo ................................................................................................... 25
4.4.1 Datos ...................................................................................................................................................... 25
4.4.1.1 Gestión de proceso ........................................................................................................................ 25
4.4.2.2 Gestión de memoria ...................................................................................................................... 25
4.4.2 Estructura del proyecto ................................................................................................................ 25
4.4.2.1 Carpetas ......................................................................................................................................... 25

pág. 2
 4.4.2.2 Ventanas ........................................................................................................................................ 28
4.4.3 Interfaces ....................................................................................................................................... 29
4.4.3.1 Interfaz FCFS ................................................................................................................................ 29
4.4.3.2 3 Colas ............................................................................................................................................ 29
4.4.3.3 Interfaz SJF_EXPROPIATIVO .................................................................................................. 30
4.4.3.4 Interfaz SJF_NO_EXPROPIATIVO .......................................................................................... 30
4.4.4 Proceso - 3 Colas ........................................................................................................................... 31
5. Supuestos ................................................................................................................................................... 34
6. Logros obtenidos ...................................................................................................................................... 34
7. Conclusiones ............................................................................................................................................. 34
8. Bibliografía ............................................................................................................................................... 35

pág. 3
 1. RESUMEN

La realización de este trabajo es un simulador de un sistema operativo, es decir, mostrar un

programa que maneje las mismas características de un sistema operativo, como el manejo de
procesos, el manejo de interrupciones y la asignación de memoria.
El manejo de procesos se da cuando el usuario pide una petición al sistema operativo. Esta
petición o inicio de proceso pasa por diferentes estados: Nuevo, Listo, Ejecutable, Interrupción,
y Fin. El estado nuevo muestra el inicio de un nuevo proceso, es decir, el proceso ya existe, pero
aún no se encuentra en memoria. El estado listo se da cuando el proceso pasa del estado nuevo
al estado listo, es decir, que dicho proceso ya existe en memoria listo para ser ejecutado por el
procesador. El estado ejecutable se da cuando el proceso se está ejecutando a través del
procesador. Sin embargo, en este estado puede ocurrir una interrupción ya sea por una petición
del sistema operativo (Aleatoria) o por una petición de un dispositivo de entrada y salida.
La simulación permite crear procesos y almacenar su tamaño de memoria en el espacio de
Memoria del S.O., además se crearán aleatoriamente las interrupciones para los procesos
almacenados. Una vez almacenado los procesos y sus interrupciones, se realizará la simulación
de los procesos, pudiendo observar la duración de cada proceso y las interrupciones que tiene,
además del espacio de memoria en todo momento. Se mostrará el desarrollo de los procesos en
una barra. Así mismo se mostrará un reporte de los dispositivos de entrada y salida que se estarán
ejecutando antes, durante y después de la ejecución de los procesos que se estarán asignando de
forma manual por el usuario.
En este trabajo, además de lo mencionado presentamos nuevos algoritmos para la planificación
de procesos (SHORT JOB FIRST, FCFS, ROUND ROBIN) complementando el trabajo ya
heredado de simulación de un Sistema Operativo.

pág. 4
 2. Introducción
Los sistemas operativos hoy en día han evolucionado conforme al avance de la tecnología.
Como sabemos un sistema operativo es un programa que nos ayuda a gestionar los recursos del
computador, así como las interfaces con el usuario. Sin embargo, este programa no solo atiende
un solo proceso, sino múltiples procesos que requiere el usuario o el mismo sistema. Es por eso
que el avance de la tecnología ha hecho que estos tipos de sistemas evolucionen, ya que,
anteriormente solo se atendían los procesos de forma secuencial, es decir, el procesador
ejecutaba los procesos y empezaba con otro cuando haya terminado con el anterior.

En este trabajo se simulará parte de las características que tiene un sistema operativo.
Aprenderemos cómo funcionan los procesos, cómo se gestiona memoria para un proceso antes
de ser ejecutado y cómo se manejan las interrupciones. En una primera etapa abordaremos el
marco teórico de nuestra simulación; es decir, basándonos en sistemas operativos reales,
veremos cómo puede funcionar nuestro simulador.

pág. 5
3. Objetivos

3.1. Objetivos Generales

Simular gráficamente la Gestión de Procesos, y de interrupciones, así como los

dispositivos de entrada y salida E/S mediante criterios de planificación y prioridades.
Para los casos de SHORT JOB FIRST, FCFS y ROUND ROBIN

3.2. Objetivos específicos

■ Simular la gestión de procesos, la planificación de procesos FCFS, SJF Y ROUND

ROBIN e interrupciones, mostrando en qué estado (nuevo, listo, ejecutando, bloqueado
o terminado) se encuentran y que tipo de interrupción se produjo.
■ Entender y explicar los métodos y conceptos usados en la Gestión de Procesos, Memoria y
Dispositivos de E/S
■ Mostar gráficamente cantidad de interrupciones totales por cada tipo de interrupción.
■ Mostrar la descripción de los bloques descriptores de cada proceso al generarse un
cambio de contexto.

pág. 6
 4. DESCRIPCIÓN DEL TRABAJO.

4.1. ANTECEDENTES Y MARCO TEÓRICO

4.1.1. Gestión de procesos

Un proceso es básicamente un entorno formado por todos los recursos necesarios para ejecutar
programas. Desde el punto de vista del SO, un proceso es un objeto más que hay que gestionar
y al cual hay que dar servicio.
Podemos decir que un programa es un conjunto de instrucciones de código máquina y datos
almacenados en un ejecutable. Mientras que un proceso sería la ejecución de ese programa, es
decir, el programa en acción. Esto indica que los procesos son dinámicos, están en constante
cambio debido a estos recursos necesarios, ya que al intentar realizar algún tipo de acción puede
ser que tenga que permanecer a la espera de que dicho recurso esté disponible, por ejemplo, una
petición de lectura del disco duro, y que el brazo lector del disco duro lo esté utilizando otro
proceso.
Al igual que las instrucciones de programa, los procesos incluyen los contadores de programa
que indican la dirección de la siguiente instrucción que se ejecutará de ese proceso y los registros
de CPU, así como las pilas que contienen datos temporales, como son los parámetros de
subrutina, las direcciones de retorno y variables locales. Los procesos también contienen una
sección de datos con variables globales y memoria dinámica. Todo ello permite gestionar de una
manera más eficaz los procesos en los sistemas operativos multiprocesos, ya que cada proceso
es independiente, por lo que el bloqueo de uno no debe de hacer que otro proceso en el sistema
se bloquee.
En estos sistemas operativos multiproceso se intenta maximizar la utilización de la CPU, por lo
que los procesos se ejecutan simultáneamente en la CPU y sólo quedan a la espera de ejecución
si requieren de algún recurso del sistema que esté ocupado en ese momento, en cuanto obtiene
dicho recurso podrá ejecutarse de nuevo. Todo este proceso de gestión lo realiza el sistema
operativo, por lo que es el que decide si un proceso es más prioritario que otros.
Cada proceso se representa en el sistema operativo con un bloque de control de proceso (PCB,
Process Control Block). En este PCB se guardan una serie de elementos de información de los
mismos. Estos elementos son: el identificador del proceso, el estado del proceso, registros de
CPU (acumuladores, punteros de la pila, registros índices y registros generales), información de
planificación de CPU (prioridad de proceso, punteros a colas de planificación, etc.), información
de gestión de memoria, información de contabilidad (tiempo de uso de CPU, números de
procesos, etc.), información de estado de dispositivos E/S (lista de archivos abiertos, etc.).

4.1.2. Estados de un proceso

Un proceso pasa por diferentes estados durante su ejecución. Los estados posibles para un
proceso se muestran en la figura siguiente:

- Nuevo
- Listo
- En ejecución
- En espera
- Terminado

pág. 7
4.1.3. Definición de estados
Nuevo: El proceso se acaba de crear, pero aún no ha sido admitido en el grupo de procesos
ejecutables por el sistema operativo.
En los sistemas operativos hay varias razones por las que se crea un proceso. Entre éstas se
pueden destacar; la inicialización del sistema, cuando se arranca el sistema se generan una serie
de procesos ya bien sean para interactuar con el usuario o procesos en segundo plano con una
función específica, como por ejemplo el aceptar la solicitud de una página web que está en dicha
máquina; ejecución de una llamada al sistema por parte de otro proceso, un proceso puede
requerir la descarga de ficheros, por lo que serán otros procesos los que se encarguen de ubicar
el archivo o archivos en la ubicación específica; por medio de la acción de un usuario, por
ejemplo al hacer doble clic en un icono; mediante el inicio de un trabajo por lotes.
Una vez el proceso ha sido creado queda a la espera de ser admitido, por lo que si es así pasaría
a estado preparado o en caso contrario terminaría dicho proceso.

pág. 8
Listo: Un proceso en este estado está esperando a que se le asigne un procesador. Como se
puede apreciar en la figura, un proceso en este estado puede, o bien finalizar, lo que ocurriría
por la acción de otro proceso o por algún acontecimiento externo, o bien el proceso pasa al
estado ejecución, ya que el gestor de procesos le asigna una CPU para ser ejecutado.

Ejecución: El proceso en este estado está en la CPU ejecutando instrucciones. Puede ocurrir
tres situaciones; que el proceso ejecute todas las instrucciones hasta su última línea de código y
finaliza; pasa a estado bloqueado por que espera una acción externa como la entrada de
información por teclado; o bien el proceso pasa a estado preparado debido a que ha agotado su
tiempo de ejecución, por lo que cede su tiempo de ejecución.

Bloqueado: El proceso está esperando a que se produzca un evento externo, como una señal de
E/S, y pasaría a estado ejecución. Al igual que el estado preparado, el proceso puede finalizar
debido a un acontecimiento externo.

El sistema operativo utiliza varias colas para gestionar los estados, cada cola puede tener una
política diferente. Así, podemos encontrar una cola para los estados preparados y una cola para
los estados en espera. El planificador del procesador al examinar estas colas asigna el procesador
al proceso más conveniente.

4.1.4. Planificación de un proceso

El sistema operativo es el encargado de decidir qué procesos entran en la CPU cuando ésta queda
libre, y en qué momento sale de la CPU el proceso que está en ejecución. Todo ello se lleva a
cabo a través de una política de planificación de procesos.
Se pueden definir múltiples políticas de planificación de procesos: por orden de llegada, primero
la tarea más breve, por orden de prioridad, etc. En definitiva, lo que una política de planificación
debe conseguir es que los procesos obtengan adecuadamente sus turnos de ejecución por lo que
son tratados de la misma forma, que no se produzca sobrecarga, es decir, el planificador debe
responder rápidamente ante cargas de trabajo ligera y responder de la misma forma ante cargas
de trabajo similares. Y obtener un buen rendimiento, por lo se debe lograr finalizar el mayor
número de procesos y maximizar el tiempo de respuesta.
Existen diferentes planificadores en el sistema. Primero nos encontramos el planificador a largo
plazo, el cual es el encargado de controlar el grado de multiprogramación en el sistema,
intentando conseguir una mezcla adecuada de trabajos en CPU y E/S. Es por tanto el encargado
de suministrar los procesos a la cola de planificación a corto plazo.
Existe también un planificador a medio plazo. Es el encargado de suspender y posteriormente
restaurar procesos de poco interés, realizando el intercambio de los mismos entre la memoria
principal y el disco o memoria secundaria. Dicho proceso es conocido como swapping, y se
ejecuta cuando hay escasez de recursos.
El planificador a corto a plazo es el encargado de asignar y desasignar la CPU. Su trabajo es
coger un proceso de la cola de procesos preparados y asignarle una CPU. Hay dos tipos de
planificadores a corto plazo; no expulsivas, el proceso abandona la CPU cuando termina o a la
espera de un suceso externo; y expulsivas, el proceso que se está ejecutando puede pasar a estado
listo enviado por parte del sistema operativo, es el caso de los sistemas de tiempo compartido y
tiempo real, como UNIX, Windows NT/XP o superior, MAC OS X.

pág. 9
4.1.5. Políticas de planificación de procesos

Las políticas de planificación de procesos más comunes son las siguientes:

- Primero en llegar, primero en salir (FCFS). El primero proceso que llega a la cola de preparados
será el primero en ser planificado y pasado a la CPU. Es no expulsiva, por lo que no es adecuada
para los sistemas de tiempo compartido, por lo que provocan una especie de convoy con los
procesos de E/S.

-Turno rotatorio (Round-Robin). Adecuado para los sistemas de tiempo compartido. Consiste
en generar periódicamente una interrupción de reloj, donde cada proceso dispone de un cuanto
de tiempo máximo (quantum), por lo que cuando termina este tiempo, el proceso en ejecución
pasa a preparado y pasa a ejecutarse el siguiente proceso en la cola de preparados según FCFS.

4.1.6. Casos de administración de procesos

Los procesos en Linux pueden ser divididos en tres categorías: interactivos, tiempo real o por
lotes. Los procesos de tiempo real son manejados bien por un algoritmo FIFO o turno rotatorio
(Round-Robin), ya que al ser procesos considerados como prioritarios deben de ser ejecutados
antes que los demás. Los demás procesos son manejados utilizando una planificación Round-
Robin con un sistema de envejecimiento utilizado en la planificación de prioridades
mencionada.
Mientras en Windows, la planificación de procesos se basa en la utilización de colas múltiples
de prioridades. Posee 23 niveles de colas clasificadas de la 31-16 en clase de tiempo real y las
demás en clase variable. Cada cola es manejada mediante Round-Robin, pero si llega un proceso
con mayor prioridad, se le es asignado el procesador.
El caso de Mac OS X es parecido al de Windows, utilizando varias colas de procesos cada una
con un nivel de prioridad. Un hilo puede pasar de una cola a otra dependiendo de los
requerimientos. Estos niveles se pueden manejar mediante llamadas al sistema. Los niveles son:
normal, alta, Kernel y tiempo real.

4.1.7. Creación y destrucción de procesos en UNIX y Windows

Los sistemas operativos que son objeto de estudio tienen diferentes formas en la gestión de
procesos, por lo que en este apartado haremos una distinción entre el sistema operativo UNIX y
Windows.

pág. 10
UNIX

Los procesos en los sistemas UNIX están identificados por un número que es único (PID),
además de que cada proceso el espacio de memoria utilizado, formado por tres segmentos: el
código, los datos y la pila. También contiene la información de control del proceso, que indica
la planificación y estado del proceso, la estructuración de datos y la comunicación entre
procesos. Otra información importante es el número de identificación de usuario (UID) y el
número de identificación del grupo de usuarios al que pertenece el proceso (GID). Todo ello
pertenece al bloque de control de proceso (PCB).
La creación y destrucción de procesos en UNIX se ajusta a la filosofía de la manera más sencilla
posible, así las llamadas al sistema tienen el mínimo número de parámetros. Las llamadas
correspondientes a la creación, destrucción y bloque o espera de un proceso son
respectivamente: fork, exit y wait.
La llamada fork crea un nuevo proceso hijo idéntico al proceso padre. Tienen la misma imagen
de memoria, el mismo bloque de control de proceso y los mismos archivos abiertos, aunque
situados en distintos espacios de memoria. Para poder distinguir a ambos procesos, la llamada
fork devuelve distintos valores, el hijo recibe un valor 0 y el padre el PID del hijo.
La llamada exit finaliza un proceso. Cuando se produce esta finalización del proceso hijo, se
manda al sistema la llamada wait, para que el padre se bloquee a la espera de la finalización del
hijo. Si el proceso hijo finalizara antes de que el padre recibiera esta llamada, el proceso hijo se
convertiría en un proceso en estado zombie, y hasta que no se ejecute esta llamada wait el
proceso no se eliminará. Para evitar la acumulación de procesos UNIX prevé un límite de
números de procesos zombie y aquellos procesos hijos que se destruyen más tarde que sus
procesos padres, al quedar huérfanos sería el primer proceso del sistema el que se encarga de
recoger su estado de finalización.
La llamada wait bloquea el proceso que lo ha llamado hasta que uno de sus procesos hijos es
destruido, por lo que si el proceso no tiene hijos wait regresa y el valor devuelto es igual al Pid
de dicho proceso hijo.
En UNIX se puede utilizar un comando para eliminar un proceso que se está ejecutando por la
razón que estimemos oportuno; gran consumo de recursos ya no es necesario, etc. Esta orden es
“kill Pid proceso a eliminar”, por lo que para eliminar un proceso primero se debe conocer su
Pid.

Windows

Un programa en Windows es controlado por eventos. Así el programa principal espera la llegada
de un evento como puede ser al presionar una tecla, y posteriormente invoca un procedimiento
para procesar dicho evento, actualización de pantalla, del programa, etc.
Windows también tiene llamadas al sistema de hecho el número de llamadas es extremadamente
grande. En Windows encontramos que por cada llamada al sistema existe un procedimiento de
biblioteca que los invoca. Por ello Windows ha creado un conjunto de procedimientos, llamado
API Win32, que se ha de utilizar para solicitar servicios al sistema operativo.
La creación de procesos en Windows se genera mediante la llamada CreateProcess, que tanto
crea el proceso como carga el programa en el nuevo proceso. Esta llamada tiene 10 parámetros:
el programa a ejecutar, atributos de seguridad, bits de control de archivos abiertos, prioridad,
especificación de la ventana a crear y un apuntador a la estructura a la que al invocador se le
devuelve información del proceso recién creado. CreateProcess tiene 100 funciones más para
administrar y sincronizar procesos.
Al igual que en UNIX, en Windows se crea un nuevo proceso hijo a partir del padre, el cual
tiene su propio espacio de direcciones como en UNIX, pero mientras en UNIX el espacio de
direcciones del hijo era una copia del padre, en Windows el espacio de direcciones del hijo es
pág. 11
completamente diferente al del padre desde el principio.
La llamada en Windows relativa a la destrucción de un proceso es ExitProcess, y al igual que
ocurría con UNIX cuando se especifica la llamada WaitForSingleObject junto con un parámetro
que especifica un proceso, quien lo invoca espera hasta que se produce la finalización del
proceso.
En Windows encontramos multitud de llamadas al sistema igual que en UNIX, aunque hay
algunas en UNIX que no se pueden utilizar en Windows, como es el manejo de enlaces, manejo
de montaje de unidades, etc. Si en UNIX utilizamos la orden kill Pid para eliminar un proceso,
en Windows existe la función TerminateProcess.

pág. 12
 4.2. Interrupciones
Las interrupciones son cambios en el flujo de control, no ocasionados por el programa que se
ejecuta, sino por algún otro suceso que necesita el servicio inmediato de la CPU por lo general
relacionado con los dispositivos de E/S. Por ejemplo, un programa puede pedirle al controlador
de disco que empiece a transferir información y que genere una interrupción cuando acabe la
transferencia.

La Figura 1 muestra, en forma muy simplificada, los pasos y los componentes involucrados en
el manejo de una interrupción. La señal de petición de interrupción provoca que la CPU detenga
el programa en curso, salve su estado (es decir, se guardan todos los contenidos de los registros
de la CPU) y transfiera el control a una Rutina de Servicio de Interrupción, o ISR (del inglés
“Interrupt Service Routine”) la cual realiza alguna acción apropiada para darle servicio a la
petición. Al terminar el servicio de la interrupción, se debe continuar el código interrumpido
exactamente en él mismo estado en que estaba cuando tuvo lugar la interrupción, lo cual se logra
restaurando los registros internos al estado que tenían antes de la interrupción previamente
salvado permitiendo continuar el flujo normal de procesamiento.
Como puede observarse, un concepto clave relacionado con las interrupciones es la
transparencia. Cuando se produce una interrupción, tienen efecto algunas acciones y se
ejecutan algunos códigos, pero cuando todo termina, la computadora se debe regresar
exactamente al mismo estado en que se encontraba antes de la interrupción.

4.2.1. Ciclo de reconocimiento de interrupción

La CPU responde a una petición de interrupción con un ciclo de reconocimiento de interrupción.

En la mayoría de las CPU la respuesta a una interrupción consta de los siguientes pasos:
1. El dispositivo de hardware genera el pulso o señal de petición de interrupción.
2. El controlador de Interrupciones Programables prioriza la petición de interrupción en relación
con las demás peticiones que podrían haberse emitido de forma simultánea (o estar pendientes)
y emite la petición de interrupción al procesador.

pág. 13
3. Si las interrupciones están habilitadas, la CPU responde con un ciclo de bus de
reconocimiento de interrupción.
4. En respuesta al reconocimiento de la CPU, el dispositivo externo (o el PIC si estuviese
presente) sitúa un vector de interrupción en el bus de datos.
5. La CPU lee el vector y lo utiliza (posiblemente de forma indirecta) para obtener la dirección
de la ISR.
6. Por último, la CPU sitúa en la pila el contexto actual, inhabilita las interrupciones, y salta a
la ISR.

4.2.2. Gestión de entrada y salida E/S

Una de las principales funciones de un sistema operativo es controlar todos los dispositivos de
Entrada/Salida que estén conectados al mismo, tales como teclado, mouse, impresora, monitos,
etc.
Existen métodos para la gestión de E/S, como:

- E/S PROGRAMADA
El procesador genera una solicitud de E/S y luego se encarga de controlar las completitudes de
la misma controlando algún registro del controlador de dispositivo. La consulta la realiza en una
iteración continúa denominada polling o busy waiting. Cabe menciona que esta técnica consume
ciclos de procesador en forma innecesaria.
Normalmente habrá muchos dispositivos de E/S conectados al sistema a través de los módulos
de E/S. Cada dispositivo tiene asociado un identificador o dirección. Cuando el CPU envía una
orden de E/S, la orden contiene la dirección del dispositivo deseado.
El problema con E/S programada es que el CPU tiene que esperar un tiempo considerable a que
el módulo de E/S en cuestión esté preparado para recibir o transmitir los datos. El CPU debe
estar comprobando continuamente el estado del módulo de E/S. Se degrada el desempeño del
sistema.
Una alternativa es que el CPU tras enviar una orden de E/S continúe realizando algún trabajo
útil. El módulo de E/S interrumpirá al CPU para solicitar su servicio cuando esté preparado para
intercambiar datos. El CPU ejecuta la transferencia de datos y después continúa con el
procesamiento previo.
Se pueden distinguir dos tipos: E/S síncrona y E/S asíncrona

 E/S Síncrona: cuando la operación de E/S finaliza, el control es retornado al proceso que la
generó. La espera por E/S se lleva a cabo por medio de una instrucción wait que coloca al
CPU en un estado ocioso hasta que ocurre otra interrupción. Aquellas máquinas que no tienen
esta instrucción utilizan un loop. Este loop continúa hasta que ocurre una interrupción
transfiriendo el control a otra parte del sistema de operación. Sólo se atiende una solicitud de

pág. 14
 E/S por vez. El sistema de operación conoce exactamente que dispositivo está
interrumpiendo. Esta alternativa excluye procesamiento simultáneo de E/S.

 E/S Asíncrona: retorna al programa usuario sin esperar que la operación de E/S finalice. Se
necesita una llamada al sistema que le permita al usuario esperar por la finalización de E/S (si
es requerido). También es necesario llevar un control de las distintas solicitudes de E/S. Para
ello el sistema de operación utiliza una tabla que contiene una entrada por cada dispositivo de
E/S (Tabla de Estado de Dispositivos). La ventaja de este tipo de E/S es el incremento de la
eficiencia del sistema. Mientras se lleva a cabo E/S, el CPU puede ser usado para procesar o
para planificar otras E/S. Como la E/S puede ser bastante lenta comparada con la velocidad del
CPU, el sistema hace un mejor uso de las facilidades.

4.2.3. Manejo de Interrupciones en Windows NT

NT define un conjunto priorizado de Niveles de Petición de Interrupción IRQL (“Interrupt

Request level”) independiente de la arquitectura. Según se muestra en la Figura, estos niveles
se hacen corresponder con los niveles de petición de interrupción de hardware; así como, con
niveles de interrupciones de software predefinidos.
Windows NT posee una arquitectura interna muy diferente de la arquitectura monolítica6 de los
núcleos de Unix tradicionales. NT posee una arquitectura alternativa que combina la arquitectura
clásica de micronúcleo (“micro-Kernel”) (introducida por sistemas tales como Mach [3] y
Chorus [5]) con la arquitectura estratificada (introducida por el sistema THE [30]). El
equivalente al núcleo de Unix es lo que en NT recibe el nombre de Ejecutivo. Lo que se
denomina núcleo en NT es sólo una parte muy pequeña del ejecutivo que sólo implementa un
conjunto de mecanismos básicos.
Hasta la versión NT 4.0 la documentación oficial de Intel menciona que el núcleo de NT es no
expropiable; ello quiere decir que, aunque el código del núcleo puede ser suspendido
temporalmente por una interrupción para la ejecución de una ISR esta siempre devolverá el
control al núcleo sin expropiar al hilo actualmente en ejecución (los hilos dentro del núcleo no
son expropiados ni siquiera cuando se le vence su cuanto de tiempo).
Cuando un hilo que se ejecuta dentro del núcleo (con un nivel IPL 0) necesita esperar por algún
evento, este cede voluntariamente la CPU invocando directamente al planificador para realizar
un cambio de contexto de forma inmediata.

pág. 15
Si el núcleo detecta la necesidad de realizar una replanificación mientras se encuentra a un nivel
de interrupción elevando (por ejemplo, como parte de la ejecución de una Llamada a
Procedimiento Diferida) entonces no invoca directamente al planificador, sino que solicita una
interrupción de nivel despacho/DPC para activar el planificador.
Como el IRQL está en ese nivel, o en uno superior, el procesador pone la interrupción en espera.
Cuando el núcleo termina su actividad actual, reduce el IRQL por debajo del nivel
despacho/DPC y se activa la interrupción DPC que causa la replanificación.
Aunque los servicios de bajo nivel del núcleo no son expropiables estos son simples y se
ejecutan muy rápidamente de manera que, el hecho de que el núcleo sea no expropiable ejerce
un mínimo impacto en la latencia de expropiación. Adicionalmente, al no ser el núcleo
expropiable se evita el problema de la inversión de prioridad no acotada (situación en la cual
una tarea de alta prioridad ve impedida su ejecución debido a la ejecución de una tarea de menor
prioridad y esto se mantiene por un tiempo no predecible). En NT, el grueso del código del
sistema reside en el ejecutivo, quien implementa las políticas y los servicios más sofisticados en
función de los servicios del núcleo. El ejecutivo se implementa mediante múltiples hilos y es
completamente expropiable. Este diseño minimiza la latencia de replanificación a la vez que
evita el problema de la inversión de prioridades no acotada.
Cuando el núcleo necesita sincronizar el acceso a estructuras internas compartidas que no son
accedidas por las ISR, no necesita inhabilitar las interrupciones de hardware; sino que,
simplemente eleva el IRQL del procesador al nivel de despacho/DPC. Esto inhabilita todas las
demás interrupciones de software incluyendo la replanificación de hilos. Sólo en el caso de que
se necesite proteger el acceso a datos compartidos entre el núcleo y las ISR, es que el núcleo de
NT eleva el IRQL del procesador hasta un nivel más alto inhabilitando cualquier fuente de
interrupción cuya ISR pudiera acceder a los datos.
Esta estrategia de sincronización funciona en sistemas con un sólo procesador, pero resulta
inadecuada para una configuración multiprocesador. Elevar el IRQL en un procesador no evita
que ocurra una interrupción en otro procesador. El núcleo necesita garantizar también acceso
mutuamente exclusivo a través de los diversos procesadores.
Para lograr exclusión mutua en un sistema multiprocesador, NT utiliza el mecanismo de cierre
de giro (“spin lock”) asociado a las estructuras de datos globales (compartidas entre varias
CPU). Mientras el cierre no está disponible la CPU se mantiene en un ciclo intentando
continuamente (en espera ocupada) hasta tanto esté disponible.
Mientras un hilo retiene un cierre de giro, existe el peligro de que algún otro código activado
por una interrupción en la misma CPU intente obtener el mismo cierre de giro. En esta situación
el código activado por la interrupción permanecería girando indefinidamente debido a que,
precisamente él está impidiendo el progreso del código que pudiera liberar el cierre. Para
impedir una posibilidad de bloqueo mutuo como esta, los cierres de giros tienen que primero
elevar el nivel de prioridad de interrupción hasta un nivel lo suficientemente alto y mantenerlo
en ese nivel mientras se retiene el cierre (se ejecuta la sección crítica).
Una vez que se libere el cierre, el nivel de interrupción debe disminuirse a su valor previo.
En NT, todos los cierres de giro de modo núcleo poseen un IRQL asociado que siempre se sitúa
a nivel de Despacho o superior. Por lo cual, cuando un hilo está intentando adquirir un cierre de
giro, todas las demás actividades al nivel IRQ del cierre o a niveles inferiores cesan en ese
procesador. Como la conmutación de hilos sucede al nivel de Despacho, un hilo que sostiene un
cierre de giro nunca es expropiado (el IRQL enmascara al mecanismo de despacho). Esto
permite que los hilos que retienen cierres de giro continúen ejecutándose para que el cierre se
libere rápidamente. El núcleo usa los cierres de giro con mucho cuidado minimizando el número
de instrucciones que ejecuta mientras retiene alguno.
NT implementa la arquitectura estándar de manejo de interrupciones en dos niveles, típica de
los sistemas operativos de red. Primero, la interrupción es manejada por una ISR muy corta.

pág. 16
Luego el trabajo se completa mediante la ejecución diferida de un Llamada a Procedimiento
Diferido o DPC (“Deferred Procedure Call”). Las ISR pueden ser interrumpidas por ISR de
mayor prioridad. Por su parte, todas las DPC se ejecutan, al nivel. A partir de Windows 2000
(NT 5.0) la documentación oficial de Microsoft ha eliminado la alusión de que el núcleo de NT
es no expropiable. Esto hace suponer que a partir de estas versiones si el núcleo no está
ejecutando código dentro de una sección crítica protegida por cierres de giros (“spinlocks”)
puede ser expropiado. De cualquier modo, en un sistema SMP el hecho de que el núcleo no sea
expropiable no garantiza protección implícita de las regiones críticas contra secciones del núcleo
que pudieran estar corriendo en otra CPU. de prioridad de despacho el cual se encuentra por
encima del nivel de prioridad de los hilos de usuario y del sistema. Esto significa que se ejecutan
con todas las interrupciones de hardware habilitadas y con la planificación y los demás DPC
inhabilitados (todos están al mismo nivel de prioridad). Los DPC se sitúan en cola en este nivel
y se planifican según una disciplina FIFO.

4.3.Gestión de memoria
La gestión de memoria se encarga de asignar la memoria física del sistema a los programas,
éstos se expanden hasta llenar la memoria con que se cuenta.
Todas las computadoras tienen una jerarquía de memoria, con una pequeña cantidad de memoria
caché, una cantidad mucho mayor de memoria principal (RAM) y decenas o centenas de
gigabyte de almacenamiento en disco.
El administrador de memoria es el encargado de administrar la jerarquía de memoria. Es el
encargado de saber qué partes de la memoria están en uso o no, asignar y liberar la memoria
principal a los procesos que la requieren, y administrar los intercambios entre la memoria
principal y el disco.
Se puede decir que los objetivos principales de un sistema de gestión de memoria pasan por
ofrecer a cada proceso un espacio lógico propio proporcionando una protección entre los
procesos, permitir que los procesos compartan la memoria. Además, se debe maximizar el
rendimiento del sistema y proporcionar a los procesos mapas de memoria grandes.
En un sistema de multiprogramación cada programa debe contener dentro del código referencias
al espacio de memoria a utilizar, ya que el mismo no siempre será el mismo, por tanto, el sistema
tendrá que realizar una reubicación de las direcciones de memoria a las que hacen referencia las
instrucciones de los programas para que se correspondan con las direcciones de memoria
principal asignadas al mismo. Esto se logra a través de la unidad de manejo de memoria (MMU),
que como se ha comentado se encarga de convertir las direcciones lógicas (memoria virtual)
emitidas por los procesos en direcciones físicas. Además, se encarga de que la conversión se
realiza con éxito y que el proceso que intenta acceder a las direcciones de memoria
correspondientes tiene permiso para ello.

4.3.1 Memoria

La memoria se puede definir como los circuitos que permiten almacenar y recuperar la
información. La unidad de almacenamiento es el bit (binary element) aunque normalmente la
consideramos estructurada en bytes (8 bits)
Aunque el byte es la unidad de direccionamiento, solemos hablar de palabras, palabra se refiere
a la longitud de los registros del microprocesador. Así hablamos de microprocesadores de 16
bits, de 32 bits.
Por razones históricas a veces se denomina palabra a 16 bits (2 bytes) y doble palabra a 32 bits.

pág. 17
 Heap: o almacenamiento libre, es el área de memoria usada para la asignación dinámica de
memoria. (memoria no predictiva)

Stack: espacio de memoria donde se encuentran almacenados las variables locales como
parámetros de un programa a ejecutar (memoria no predictiva).

4.3.1.1 Estrategias de asignación

En la asignación de memoria a un procesos existe varias ventajas .
1. FIRST FIT. El Sistema Operativo asigna el primer bloque de memoria libre con espacio suficiente para
satisfacer la información. La búsqueda de este bloque es de manera secuencial.
2. BEST FIT. El sistema operativo busca el bloque de memoria que represente el menor desperdicio según el
requerimiento.
3. WORST FIT. El sistema operativo asigna el bloque más grande que encuentre.

pág. 18
4.3.1.2 Fragmentación de la memoria:

Al igual que ocurre con los sistemas , la memoria puede presentar fragmentación inter y
externa.

 Fragmentación interna:
Memoria que se desperdicia por ser las unidades de asignación de tamaño fijo y no ser los
requerimientos de los procesos múltiplos exactos de la unidad de asignación.

 Fragmentación externa
Memoria que no se puede asignar por no estar contigua, típica de los sistemas que utilizan
segmentación.

4.3.2.2 Protección de la memoria

La memoria debe estar protegida de manera que

 Un proceso no pueda acceder directamente a la memoria del S.O.
 Un proceso no pueda acceder a la memoria de otros procesos.

Las maneras más elementales de implementar la protección son:

 Con dos registros límite.
 Con un registro base y un registro límite.

a) Con dos registros límite

Cada vez que un proceso genera una dirección se comprueba si es mayor que el registro límite
inferior y menor que el superior. De no ser así se genera una excepción
El hardware ha de proporcionar dichos registros límite.
El cambio de contexto actualizará el valor de dichos registros límite.
El cambio de valores de los registros límite ha de ser una instrucción privilegiada.
b) Con registro base y registro límite
Cada vez que un proceso genera una dirección se comprueba si es menor que el registro límite.
En caso de serlo, la dirección física se obtiene sumando el valor del registro base. De no ser así
se genera una excepción.

pág. 19
El hardware ha de proporcionar dichos registros.
El cambio de contexto actualizará el valor de dichos registros.
El cambio de valores de los registros límite ha de ser una instrucción privilegiada.
Este esquema proporciona además una manera de relocalización dinámica.

4.3.1.4 Swapping

Es mover un proceso o parte de él temporalmente desde la memoria principal a un dispositivo

secundario de almacenamiento (memoria de apoyo) para luego devolverlo a la memoria
principal. El propósito de esta técnica es que el sistema operativo sea capaz de asignar más
memoria de la que tiene físicamente. De esta forma, en el caso que algún proceso requiera de
memoria y ya esté toda asignada o no haya suficiente, el kernel se preocupa de intercambiar
páginas de memoria desde y hacia la memoria de apoyo para hacerle espacio.

La memoria de apoyo debiera ser rápida y de tamaño suficiente para almacenar las copias de
imágenes de memoria de los procesos, también debe proporcionar acceso directo a estas
imágenes. El disco duro es usualmente quien funciona como memoria de apoyo.

Todos los sistemas operativos actuales cuentan con alguna versión de swapping (Windows,
Linux y UNIX). El sistema mantiene una cola de procesos en estado ready que están listos
para ser ejecutados y cuyas imágenes de memoria se encuentran en el disco.

pág. 20
4.3.1.4 Memoria virtual

La memoria virtual es una técnica de gestión de la memoria que permite que el sistema
operativo disponga, tanto para el software de usuario como para sí mismo, de mayor cantidad
de memoria que esté disponible físicamente. La mayoría de los ordenadores tienen cuatro
tipos de memoria: registros en la CPU, la memoria caché (tanto dentro como fuera del CPU),
la memoria RAM y el disco duro. En ese orden, van de menor capacidad y mayor velocidad
a mayor capacidad y menor velocidad.

Muchas aplicaciones requieren acceso a más información (código y datos) que la que se puede
mantener en memoria física. Esto es así sobre todo cuando el sistema operativo permite
múltiples procesos y aplicaciones ejecutándose simultáneamente. Una solución al problema
de necesitar mayor cantidad de memoria de la que se posee consiste en que las aplicaciones
mantengan parte de su información en disco, moviéndola a la memoria principal cuando sea
necesario. Hay varias formas de hacer esto.

pág. 21
MMU (Memory Management Unit)
Dispositivo hardware que traduce direcciones virtuales en direcciones físicas. También implementa
protección. El hardware determina la forma en la que el SO gestiona la MMU. En el esquema MMU
más simple, el valor del registro de reubicación se añade a cada dirección generada por el proceso de
usuario al mismo tiempo que es enviado a memoria. 23 SOI MMU Memoria CPU MMU Bus
instrucciones/datos Dirección virtual Microprocesador.

pág. 22
 4.3.2.1 Paginación

En sistemas operativos de computadoras, los sistemas de paginación de memoria dividen los programas
en pequeñas partes o páginas. Del mismo modo, la memoria es dividida en trozos del mismo tamaño
que las páginas llamados marcos de página. De esta forma, la cantidad de memoria desperdiciada por
un proceso es el final de su última página, lo que minimiza la fragmentación interna y evita la externa.

En un momento cualquiera, la memoria se encuentra ocupada con páginas de diferentes procesos,

mientras que algunos marcos están disponibles para su uso. El sistema operativo mantiene una lista de
estos últimos marcos, y una tabla por cada proceso, donde consta en qué marco se encuentra cada
página del proceso. De esta forma, las páginas de un proceso pueden no estar contiguamente ubicadas
en memoria, y pueden intercalarse con las páginas de otros procesos.

En la tabla de páginas de un proceso, se encuentra la ubicación del marco que contiene a cada una de
sus páginas. Las direcciones lógicas ahora se forman como un número de página y de un
desplazamiento dentro de esa página (conocido comúnmente como offset). El número de página es
usado como un índice dentro de la tabla de páginas, y una vez obtenida la dirección del marco de
memoria, se utiliza el desplazamiento para componer la dirección real o dirección física. Este proceso
se realiza en una parte del computador específicamente diseñada para esta tarea, es decir, es un proceso
hardware y no software.

De esta forma, cuando un proceso es cargado en memoria, se cargan todas sus páginas en marcos libres
y se completa su tabla de páginas.

pág. 23
 4.3.2.2 Direccionamiento de paginación

El espacio de direcciones lineales está dividido en intervalos de largo fijo llamados páginas.
La unidad de paginación abstrae a la memoria física como fraccionada en intervalos de largo fijo y del
mismo tamaño que la página (marcos - frames).

Tamno de la pagina es 2^n

pág. 24
 4.4 Arquitectura del Software prototipo

4.4.1 Datos

4.4.1.1 Gestión de proceso

Los procesos que generaran Aleatoriamente estarán en el siguiente rango:

 N°proces: <3-15>
 Proceso : <0-63>KB
 Burst time : <0-10> “S”
Se desarrolla los tres tipos de planificadores:
 FCFS
 ROUND ROBIN
 SJF
Distribuidos en 3 partes Iguales

4.4.2.2 Gestión de memoria

Algoritmo de asignación: FIRST FIT

Técnica de asignación: Paginación
 RAM: 512KB
 Tamaño de la página:8kB
 N° de paginas: 64 ( 0 – 63)

4.4.2 Estructura del proyecto

4.4.2.1 Carpetas
pág. 25
El proyecto está compuesto de 4 carpetas fundamental que constan del código fuente, hojas
de estilo y los gráficos estadísticos correspondientes.

a) Carpeta font: contiene el manejo de los colores y tipo de letra de la interfaz. Ej.: PCB
(Bloque Descriptor de Procesos), tabla que muestra el listado de procesos.

b) Carpeta CSS: ayuda a crear estilos de presentación de la interfaz.

pág. 26
c) Carpeta img: contiene las imágenes y avatares para la presentación de la página web.

d) Carpeta js: Contiene el código fuente para la elaboración de cada uno de los tipo de
planificación.

pág. 27
4.4.2.2 Ventanas

Paquetes donde se incluyen los 4 módulos principales del programa: 4 simuladores de procesos y
uno de memoria según su tipo de planificación.

En esta parte se tienen solo dos archivos html que se ejecutan:

o FCFS.html: Inicializa con el ingreso de un número de procesos definido por el

usuario, a partir de ella se crea una una lista de procesos cuyos tiempos de arribo y
tiempos de ejecución se generan de manera aleatoria.
o 3 COLAS.html: Inicializa el ingreso de un quantum definido por el usuario y la
inicialización de una cantidad de procesos de manera aleatoria Para los 3 formas
de Gestionar el Planificador FCFS, SJJ y Round Robin.
o SJF_NO_EXPROPIATIVO .html: Una vez la CPU es asignada al proceso no
puede ser expropiado hasta que termine su ráfaga de CPU (SPN).
o SJF_EXPROPIATIVO .html: Si llega un nuevo proceso con una longitud de
ráfaga menor que el tiempo restante del proceso en ejecución, este es expropiado.
o Memoria.html: Inicializa al introducir los números de procesos por el usuario, y
refleja que se pinta una parte de la memoria de acuerdo a su paginación.

pág. 28
4.4.3 Interfaces
4.4.3.1 Interfaz FCFS

4.4.3.2 3 Colas

pág. 29
4.4.3.3 Interfaz SJF_EXPROPIATIVO

4.4.3.4 Interfaz SJF_NO_EXPROPIATIVO

pág. 30
 4.4.4 Proceso - 3 Colas

En el software se muestra tres tipos de planificación para los procesos. En cada ventana se
agregan procesos a la simulación, también el mapeo de memoria que muestra los frames con
información importante de ellos.
Del proceso a simular se agregará el burst-time y los tiempos de arribo automáticamente se
generarán las interrupciones puede ser: E/S, memoria, etc.
GENERAR PROCESOS

pág. 31
DETERMINAR CANTIDAD DE PROCESOS:

SALTAN INTERRUPCIONES:

pág. 32
PROCESAMIENTO

pág. 33
 5. Supuestos

 El lenguaje de programación usado es Javascript y el IDE empleado

 La cantidad de interrupciones son generadas por números random aleatorios.
 La memoria total es de 4 GB
 El sistema operativo ocupa 1GB del total de 4Gb (64 frames).
 El frames empleado es de 64MB.
 El SO trabajo bajo el sistema de planificación FCFS, SJF Y ROUND ROBIN.
 Los tiempos de aparición de las interrupciones siguen una distribución uniforme.
 Se cuenta con gestión de dispositivos de entrada y salida de mouse, teclados, parlante
y USB.
 Las interrupciones añadidas son de la creación de un hijo, tiempo expirado y de
entrada y salida.

6. Logros obtenidos

 Desarrollo del aplicativo en lenguaje de programación Java para los planificadores

de procesos FCFS, SJF y RR:
 Implementar la gestión de procesos, y el manejo de interrupciones.
 Representación de las funcionalidades básicas que realizan los sistemas operativos.
 Observar características del comportamiento de la memoria según un planificador.
 Obtener datos cuantificables y estadísticos por cada planificador.
7. Conclusiones

 los procesos al ser ejecutados pasan por una serie de estados y se puede
corroborar mediante los diversos tipos de planificación, asi como también a la
hora de que se presente cualquier interrupción.
 Los procesos actúan como un bloque que tiene diversas características es por
eso que se considera como PCB.

pág. 34
8. Bibliografía
8.1 TFC: Arquitectura de computadores y sistemas operativos
http://openaccess.uoc.edu/webapps/o2/bitstream/10609/8179/1/fserranocaTFC0611
.pdf
8.2 Centro de investigación y de estudios avanzados del instituto politécnico nacional
Administración de interrupciones en sistemas operativos de tiempo real
http://www.atc.uniovi.es/telematica/2ac/Apuntes-y-Ejercicios/T08-Procesos.pdf
8.3 Trabajo realizado por el grupo anterior
8.4 Diapositivas de clase

pág. 35