ARQUITECTURA DE COMPUTADORAS
CURSO 2016 MODALIDAD TOP DOWN
GRUPO 24
Informe Laboratorio 8086
Integrantes:
Sofa MARTNEZ - 4577510-9
Cecilia PIROTTO - 4930547-7
Fernando RBAGO - 4867039-8
Nicols RIBERO - 4590761-1
1
ndice
Caratula.1
ndice..2
Descripcin del problema.3
Descripcin de la solucin...5
o Vector de Rutinas.5
o Vector Round Robin6
o Stack de Rutinas6
o Variables y constantes.6
o Solucin de cada interrupcin7
Experimentacin y problemas encontrados.12
o Caso de prueba 1..12
o Caso de prueba 2..15
o Caso de prueba 3..16
Mejoras a futuro..20
Referencias..21
2
Descripcion del problema:
El problema se basa en el desarrollo de software de un gestor de rutinas
(implementado en assembler 8086) necesario para poder gestionar el uso compartido
del procesador por parte de las rutinas registradas en el sistema. La asignacin de
procesador a rutinas debe estar basado en un esquema circular de tiempo fijo. Esto es,
el gestor de rutinas debe asignarle un tiempo fijo o slot de tiempo (time-slot) a cada
rutina registrada en el sistema para ejecucin y cuando este vence se pasa a la
siguiente de la lista de forma circular. Para esto se utiliz el simulador ArquiSim, el cual
permite el desarrollo de dicho software en lenguaje ensamblador y simular la
ejecucin sobre una arquitectura 8086.
El gestor de rutinas deber realizar todas las inicializaciones necesarias y proporcionar
distintos servicios al cdigo de usuario. Los servicios se implementarn en forma de
llamadas al sistema a travs de la instruccin INT.
Las interrupciones implementadas son:
1. agregar_rutina (INT 100)
La interrupcin de software 100 brindar el servicio de instalar una nueva rutina a
ser ejecutada por el gestor de tareas. Cuando se invoca este servicio el sistema de
gestin registra la rutina. Este servicio necesita recibir algunos parmetros, los cuales
recibir en los siguientes registros:
a) AX: segmento donde se encuentra cargada la rutina a instalar.
b) BX: desplazamiento respecto de AX de la primera instruccin ejecutable de la rutina
a instalar.
Este servicio devuelve en CX el nmero de rutina asignado por el gestor o valores
negativos (identificadores) en caso de error.
2. arrancar_rutina (INT 101)
La interrupcin 101 permite modificar el estado de una rutina registrada de forma que
el gestor la considere al momento de realizar la asignacin de CPU. Este servicio recibe
3
en AX el identificador de la rutina a arrancar y devuelve en BX el resultado de la
operacin (0 en caso de xito o valores negativos en caso de error)
3. detener_rutina (INT 102)
La interrupcin 102 permite modificar el estado de una rutina en ejecucin de forma
que el gestor, por el momento, no le asigne el procesador para ejecutar. Este servicio
recibe en AX el identificador de la rutina a detener y devuelve en BX el resultado de la
operacin (0 en caso de xito o valores negativos en caso de error).
4. arrancar_todas_rutinas (INT 103)
dem a la interrupcin 101 pero arrancando todos las rutinas registradas.
5. eliminar_rutina (INT 104)
La interrupcin 104 le brinda a las rutinas registradas una forma prolija de terminar.
Una tarea que ejecuta la interrupcin 104 ser quitada del proceso de asignacin de
procesador. Este servicio recibe en AX el identificador de la rutina a eliminar y
devuelve en BX el resultado de la operacin (0 en caso de xito o valores negativos en
caso de error).
6. uso_procesador (INT 105)
La interrupcin 105 devuelve la cantidad de slots de tiempo que le fueron asignados a
una determinada rutina. Este servicio recibe en AX el identificador de la rutina a
consultar y devuelve en BX la cantidad de slots de tiempo completamente utilizados
por ella.
7. ceder_procesador (INT 106)
Cede el slot de tiempo de procesador, de forma que el gestor asigne otra tarea a
ejecutar.
4
Descripcion de la solucion:
El problema se resolvi implementando los diferentes servicios y un timer en forma de
interrupciones. Para esto se utilizaron diferentes espacios de memoria que detallamos
a continuacin:
Vector de Rutinas:
En este vector se guarda la informacin de cada rutina, el tamao asignado para cada
rutina est definido por nuestra constante tamanioR.
A partir de DS:[100] es donde comienza nuestro vector, de esta forma el comienzo de
memoria para cada rutina se calcula como idRutina*tamanioR+100.
Un ejemplo para la primer rutina instalada en memoria (segmento DS) donde podemos
ver la informacin almacenada sera el siguiente:
100 Se guarda el id de la rutina
102 Guardo la direccin fsica donde se encuentra la rutina
104 Indicamos con el valor 0, 1,2 si la rutina se encuentra detenida (0), si est
arrancada (1) o eliminada (2)
106 Se guarda el IP de la rutina para saber dnde se estaba ejecutando al momento
de ceder el procesador
108
Posicin de la "base" del stack asignada para esta rutina
110 Posicin del "tope" del stack asignada para esta rutina
112 Cantidad de slots de tiempo utilizados por la rutina
114 Se guardan las FLAGS de la rutina para poder guardar el contexto al momento de
ceder el procesador
116 Se guarda el SEGMENTO de la rutina para poder guardar el contexto al momento
de ceder el procesador
5
Vector Round Robin:
A partir del DS[vector], (siendo vector=16384 bytes) se encuentra el vector Round
Robin el cual contiene los id de las rutinas agregadas al sistemas. Es el vector que ser
consultado por el gestor para saber que rutina se est ejecutando y cual sera la
siguiente. Cada vez que una rutina es agregada al sistema la misma se coloca al final
del vector y solamente es sacada del mismo cuando es eliminada. En este caso el resto
son desplazadas para no dejar lugares libres.
Stack de Rutinas:
Definimos el comienzo del SS en la posicin 0xFEEE. A partir de SS:[100] comienza el
stack destinado a cada rutina. Los primeros 100 bytes son para el stack utilizado por el
main antes de ejecutarse alguna rutina. Cada rutina dispone de 64 bytes de memoria
para su stack, en caso de utilizar ms pisara el stack de la rutina siguiente. De todas
formas este tamao fue definido a travs de una constante (tamanioStackRutina) por
lo que podra aumentarse en caso de ser necesario.
Por lo tanto el stack destinado a cada rutina va a comenzar a partir de la direccin de
memoria SS:[idRutina*tamanioStackRutina +100]. Siendo idRutina el identificador de
cada rutina.
Variables y constantes:
Se utilizaron diferentes espacios de memoria utilizados como variables para poder
resolver el problema:
DS:[50] guarda el identificador de la rutina con mayor id agregada al vector de rutinas.
DS:[52] desplazamiento respecto a 100 donde se encuentra la prxima posicin libre
para instalar una nueva rutina en el vector de agregadas.
DS:[54] la cantidad de lugares libres (en la que se encontraba una rutina y luego fue
eliminada) en la memoria, para instalar una nueva rutina.
DS:[56] guarda el desplazamiento respecto a vector donde se encuentra la ltima
rutina en el vector Round Robin.
DS:[58] guarda el desplazamiento respecto a vector donde se encuentra la rutina que
se est ejecutando.
DS:[60] es para indicar si se est ejecutando una rutina o no. Si se encuentra en 1
quiere decir que se est ejecutando una rutina y si el estado se encuentra en 0 no se
6
est ejecutando una rutina. Esto nos sirve para saber cundo incrementar los tics del
timer para luego poder controlar los slots de tiempo.
DS:[62] son la cantidad de tics del timer , los cuales cuando lleguen a 8 tics significa
que se complet un slot de tiempo para una rutina.
DS:[66] bandera que me indica si la interrupcin 104- Eliminar rutina se llama desde la
rutina que se quiere eliminar (autoelimina)
DS:[68] guarda el identificador de la rutina auto eliminada.
DS:[70] guarda el ltimo puerto utilizado (para poder imprimir en puertos diferentes
las diferentes interrupciones ejecutadas).
Tambin fueron definidas las siguientes constantes:
TamanioR EQU 32:
Es el tamao definido para cada rutina en el vector de rutinas.
vector EQU 16384:
Comienzo de vector(Round Robin) de rutinas en el segmento DS.
tamanioStackRutina EQU 64:
Tamao del stack de cada rutina en el SS(Stack Segment).
slotTiempo EQU 8:
Cantidad de tics del timer para definir 1 slot de tiempo.
#define SS 0XFEEE:
Comienzo del SS (Stack Segment) para no pisar memoria del DS.
Solucin de cada interrupcin (servicio):
timer(INT 8)
Esta interrupcin va a interrumpir cada cierta cantidad de instrucciones ejecutadas,
definimos que esa cantidad sea mayor a las que se ejecutan dentro del timer para que
una vez que interrumpa no quede en un bucle infinito.
7
Como el hardware del temporizador PIT (Programmable Interval Timer) no est
conectado al 8086, sino que se conecta al PIC (Programmable Interrupt Controller)
quien maneja las interrupciones por hardware, no hay manera que el PIT detecte que
las interrupciones se han habilitado para resetear el contador que lo dispara. Este es el
motivo por el cual hay casos en donde el timer interrumpe dos veces consecutivas.
Se comienza verificando si se estaba ejecutando una rutina o no (DS:[60]). En el caso
que no, se va a una etiqueta al final de timer y termina la interrupcin, porque al
interrumpir, o se terminaba de ejecutar otra interrupcin o no haban rutinas
ejecutando. De esta manera no se incrementa la cantidad de tics quitndole tiempo de
ejecucin a otra rutina.
En el caso que el timer interrumpa una rutina se incrementa la cantidad de tics y se
verifica si la rutina complet el slot de tiempo definido para ceder el procesador.
De no haber completado, el timer finaliza habiendo slo incrementado los tics.
De pasar las verificaciones anteriores se estara en el caso que se estaba ejecutando
una rutina y se complet el slot de tiempo disponible, por ende, es necesario salvar el
contexto de esta rutina, elegir la prxima rutina a ejecutar y cargar su contexto.
Guardar el contexto de la rutina que termina implica acceder a su espacio de memoria
y pushear en su stack los registros que puede haber utilizado, incremento en uno la
cantidad de slots de tiempo que va ejecutando hasta el momento y se guarda el CS,
flags e IP que hay en el tope del stack para cuando se vaya a retomar la ejecucin de la
rutina.
A continuacin se busca la siguiente rutina a ejecutar en el vector Round Robin, se
elige la siguiente que no est detenida y en caso que se llegue al final sin poder elegir
una se comienza del principio del vector.
Por ltimo, en caso que la rutina ya se haya ejecutado anteriormente se popea del
stack los registros salvados y se pushean el CS, flags e IP guardados.
En caso que la rutina se venga a ejecutar por primera vez solo se cargan CS, flags e IP
cargados en la memoria de la rutina en el momento de agregarla.
agregar_rutina(INT 100)
Para comenzar se toma el segmento que recibido en el registro AX, se multiplica por 16
y se suma el desplazamiento pasado en BX para obtener el lugar en la memoria fsica
8
donde se encuentra la rutina que pasada por parmetro para poder agregarla. Luego
se consulta si hay un espacio de memoria libre (huecos en el vector de rutinas) donde
se encontraba una rutina que ha sido eliminada para agregar la nueva rutina, para eso
se pregunta en DS:[54] si es diferente a 0, con el fin de reutilizar la memoria.
En el caso que no haya un espacio libre, se accede al lugar de la memoria que le va a
corresponder a la rutina a agregar, para poder instalarla, multiplicando el identificador
de la rutina, que le fue asignado por el DS:[50], por el tamao de memoria que tiene
cada rutina en el segmento DS (idrutina*tamanioR) y luego desplazndonos 100 bytes,
ya que a partir de DS:[100] es el lugar donde fueron instaladas las rutinas. En el caso
contrario, se busca el espacio libre dejado por la rutina que fue eliminada.
En el segmento de memoria que le corresponde a la rutina a agregar se guarda: su
identificador, la direccin de memoria fsica donde se encuentran sus instrucciones, el
estado en detenida, y su IP para saber luego donde se encontraba ejecutando al
momento de ceder el procesador.
Luego es definido el segmento de stack(SS) que va a utilizar la rutina, para esto se
multiplica el identificador (idrutina) por el tamao del stack predefinido
(tamanioStackRutina) sumndole 100 por convencin ya que a partir de SS:[100] es el
lugar donde las rutinas utilizan el stack.
arrancar_rutina(INT 101)
En AX se recibe el identificador de la rutina a arrancar, a ste se lo multiplica por el
tamao de memoria asignado a cada rutina para acceder al comienzo de su espacio de
memoria.
Luego se pone en 1 el lugar en la memoria que indica el estado de la rutina
(arrancada).
detener_rutina(INT 102)
En AX se recibe el identificador de la rutina a detener, a ste se lo multiplica por el
tamao de memoria asignado a cada rutina para acceder al comienzo de su espacio de
memoria.
Luego se pone en 0 el lugar en la memoria que indica el estado de la rutina (detenida).
arrancar_todas_rutinas(INT 103)
9
Se comienza a recorrer el espacio de rutinas comenzando desde el idrutina = 0,
incrementando el id y calculando el espacio de la prxima rutina a arrancar.
En cada espacio de rutina se consulta el lugar en la memoria que indica el estado de la
rutina, si est eliminada no se hace nada, sino se le asigna el valor 1 (arrancada).
eliminar_rutina(INT 104)
Antes de comenzar a eliminar la rutina se verifica si la rutina se est autoeliminando.
Para esto, se compara el id de rutina recibido en AX, con el valor que se encuentra en
el vector Round Robin segn lo indicado en DS:[58] (rutina que se est ejecutando).En
caso que se est autoeliminando, se activa la bandera y se guarda el id de la rutina.
Lo anterior sirve para actualizar de forma correcta el DS:[58] cuando se vaya a
actualizar el vector RR, para que los corrimientos en el vector no afecten esta variable.
Adems al momento de ceder el procesador, si se est autoeliminando, la misma
rutina era quien estaba ejecutando, por ende, no se debe guardar el contexto de la
rutina.
Para eliminar la rutina, como en AX se recibe el identificador de la rutina, a ste se lo
multiplica por el tamao de memoria asignado a cada rutina para acceder al comienzo
de su espacio de memoria.
Luego se pone en 2 la direccin que indica el estado de la rutina (eliminada).
Adems se resetean algunos valores de su espacio de rutina para poder reutilizarlos en
caso que luego se agregue otra rutina: Tope en su espacio de stack, slots de tiempo
utilizados por la rutina. Se incrementa la variable global que indica la cantidad de
lugares libres es el espacio de las rutinas.
Se actualiza el vector Round Robin, quitndose del mismo el id de rutina eliminada y
dejando la cola de procesos ordenada para el planificador.
Para eso, primero se identifica la rutina eliminada en el vector, luego se va
intercambiando de lugar con la siguiente hasta llegar al final, en ese momento el id de
rutina a eliminar est en el ltimo lugar y por ltimo se decrementa el tope del vector,
que es el desplazamiento respecto del comienzo del vector, donde se encuentra la
ltima rutina.
uso_procesador(INT 105)
10
En AX se recibe el identificador de la rutina de la cual se quiere saber el uso del
procesador, a ste se lo multiplica por el tamao de memoria asignado a cada rutina
para acceder al comienzo de su espacio de memoria.
Luego se carga en BX el valor que tiene el lugar en la memoria (de la rutina) que indica
el uso de procesador para esa rutina.
Este valor se incrementa cada vez que la rutina ejecuta un slot de tiempo completo.
ceder_procesador(INT 106)
Esta interrupcin tiene la misma lgica que el timer pero sin incrementar tics ni
consultar si completo el slot de tiempo (ya que en este caso el gestor debe asignar una
nueva rutina a ejecutar sin tener en cuenta si el slot fue completado).
11
Experimentacion y problemas
encontrados:
Casos de Prueba:
Caso de Prueba 1:
Este caso fue realizado con el fin de probar el comportamiento del sistema utilizando
las interrupciones agregar, arrancar y eliminar rutina. Para esto, primero se definen
cuatro rutinas.
La rutina0 incrementa la posicin de memoria ds:[40] hasta que sta llegue a
50 (32h), en ese momento se autoelimina y cede el procesador.
La rutina1 incrementa la posicin de memoria ds:[40] hasta que sta llegue a
70 (46h), en ese momento agrega la rutina0 (en estado detenida) y la vuelve a
arrancar, luego cede el procesador.
La rutina2 solamente incrementa la posicin de memoria ds:[38].
La rutina3 consulta el uso del procesador de cada rutina.
.code
cli
mov ds:[50], 0xFFFF
mov byte ptr ds:[54], 0
mov ds:[56], 0xFFFE
mov AX, segment rutina0
mov BX, offset rutina0
sti
int 100
cli
mov ax, segment rutina1
mov bx, offset rutina1
sti
int 100
cli
mov ax, segment rutina2
mov bx, offset rutina2
sti
int 100
int 103
cli
mov ax, segment rutina3
mov bx, offset rutina3
sti
int 100
mov ax, cx
12
int 101
mov bp, 100
mov sp, 100
rutina0 proc
mov byte ptr ds:[60],1 ; ----------ACA EMPIEZA EL PROC 0---------
mov byte ptr ds:[40],1
while_rutina0:
inc byte ptr ds:[40]
cmp byte ptr ds:[40], 50
je Eliminar_rutina
jmp while_rutina0
Eliminar_rutina:
mov ax, 0
int 104
int 106
jmp while_rutina0
ret
rutina0 endp
rutina1 proc
mov byte ptr ds:[60],1 ; ---------ACA EMPIEZA EL PROC 1----------
mov byte ptr ds:[10],1
while_rutina1:
inc byte ptr ds:[10]
cmp byte ptr ds:[10], 70
je Eliminar_rutina2
jmp while_rutina1
Eliminar_rutina2:
cli
mov ax, segment rutina0
mov bx, offset rutina0
sti
int 100
mov ax, cx
int 101
int 106
jmp while_rutina1
ret
rutina1 endp
rutina2 proc
mov byte ptr ds:[60],1 ;----------ACA EMPIEZA EL PROC 2-----------
mov byte ptr ds:[38],1
while_rutina2:
inc byte ptr ds:[38]
jmp while_rutina2
Eliminar_rutina3:
mov ax, 1
int 104
ret
rutina2 endp
rutina3 proc
mov byte ptr ds:[60],1 ; -----------ACA EMPIEZA EL PROC 3------------
while_rutina3:
mov ax, 0
int 105
mov ax, 1
int 105
mov ax, 2
13
int 105
mov ax, 3
int 105
jmp while_rutina3
ret
rutina3 endp
Se comenz el caso de prueba definiendo las rutinas, y agregando en primer lugar las rutinas 0,
1 y 2 al sistema para inmediatamente arrancarlas (mediante int 100 e int 103
respectivamente).
Luego se instala y se arranca solamente la rutina3.
Se comienza a ejecutar la rutina0. El timer ser el encargado de alternar el procesador entre
las cuatro rutinas a medida que cada una completa su slot de tiempo.
La rutina2, consulta el uso del procesador de todas las rutinas, en este momento, las rutinas 0,
1 y 2 han completado un slot de tiempo cada una, mientras que la 3 (que se est ejecutando),
no ha completado ninguno.
Luego, cuando se ejecuta la rutina0 nuevamente sta se autoelimina y la rutina1 la vuelve a
agregar, hacindolo en la posicin 0, ya que la coloca en el lugar que haba quedado libre.
Nuevamente, el timer alterna el procesador entre las cuatro rutinas, hasta que ejecuta la
rutina0, lo que quiere decir que qued agregada correctamente.
Resumiendo, la salida debera ser la siguiente:
Salidas:
Puerto 0: 2, 100, 0, 3
Puerto 1: 2, 100, 1, 3
Puerto 2: 2, 100, 2, 3
Puerto 3: 2, 103, 0, 3
Puerto 4: 2, 103, 1, 3
Puerto 5: 2, 103, 2, 3
Puerto 6: 2, 100, 3, 3
Puerto 7: 2, 101, 3, 3
Puerto 8: 2, 8, 0, 1, 3
Puerto 9: 2, 8, 1, 2, 3
Puerto 10: 2, 8, 2, 3, 3
Puerto 11: 2, 105, 0, 1, 3
Puerto 12: 2, 105, 1, 1, 3
Puerto 13: 2, 105, 2, 1, 3
Puerto 14: 2, 105, 3, 0, 3
Puerto 15: 2, 8, 3, 0, 3
Puerto 16: 2, 104, 0, 3
Puerto 17: 2, 8, 0, 1, 3
Puerto 18: 2, 100, 0, 3
Puerto 19: 2, 8, 1, 2, 3
Puerto 20: 2, 8, 2, 3, 3
Puerto 21: 2, 105, 0, 0, 3
Puerto 22: 2, 105, 1, 2, 3
Puerto 23: 2, 105, 2, 2, 3
Puerto 24: 2, 105, 3, 1, 3
Puerto 25: 2, 8, 3, 1, 3
Puerto 26: 2, 101, 0, 3
Puerto 27: 2, 106, 1, 2, 3
Puerto 28: 2, 8, 2, 3, 3
Puerto 29: 2, 105, 0, 0, 3
Puerto 30: 2, 105, 1, 3, 3
Puerto 31: 2, 105, 2, 3, 3
Puerto 32: 2, 105, 3, 2, 3
Puerto 33: 2, 8, 3, 0, 3
14
Caso de Prueba 2:
Este caso fue hecho con el fin de probar las interrupciones de detener y arrancar rutina. Para
esto fueron definidas dos rutinas.
La rutina0 incrementa la posicin de memoria ds:[40] hasta que sta llega a 50 (32h),
en ese momento la rutina0 es detenida.
La rutina1 incrementa la posicin de memoria ds:[38] hasta que sta llega a 200 (C8h),
en ese momento la rutina0 es arrancada.
cli
mov ds:[50], 0xFFFF
mov byte ptr ds:[54], 0
mov ds:[56], 0xFFFE
mov AX, segment rutina0
mov BX, offset rutina0
sti
int 100
cli
mov ax, segment rutina1
mov bx, offset rutina1
sti
int 100
int 103
mov byte ptr ds:[60],1
int 106
rutina0 proc
mov byte ptr ds:[60],1 ; -----ACA EMPIEZA LA RUTINA 0-------------
mov byte ptr ds:[40],1
whileRutina0:
inc byte ptr ds:[40]
cmp byte ptr ds:[40], 50
je Detener
jmp whileRutina0
Detener:
mov ax, 0
int 102
jmp whileRutina0
ret
rutina0 endp
rutina1 proc
mov byte ptr ds:[60],1 ; -----ACA EMPIEZA LA RUTINA 1--------------
mov byte ptr ds:[38],1
whileRutina1:
inc byte ptr ds:[38]
cmp byte ptr ds:[38], 200
jne whileRutina1
mov ax, 0
15
int 101
jmp whileRutina1
ret
rutina1 endp
Comenzamos nuestro caso de prueba definiendo las rutinas, las cuales son agregadas al
sistema y arrancadas (mediante int 100 e int 103 respectivamente). Luego el procesador es
cedido (int 106) para que el gestor le asigne el procesador a una rutina y comience a ejecutarse
hasta completar el slot de tiempo cuando el procesador ser cedido a la siguiente siguiendo el
algoritmo Round Robin.
El timer ser el encargado de alternar el procesador entre ambas rutinas a medida que cada
una completa su slot de tiempo hasta que la rutina0 sea detenida. En este momento el gestor
tendr una sola rutina para ejecutar por lo que el procesador debe ser cedido a ella misma
hasta que vuelva a arrancar la rutina0. A partir de este momento el procesador debe ser
alternado entre ambas nuevamente.
Resumiendo, la salida debera ser la siguiente:
Puerto 0: 2, 100, 0, 3
Puerto 1: 2, 100, 1, 3
Puerto 2: 2, 103, 0, 3
Puerto 3: 2, 103, 1, 3
Puerto 4: 2, 106, 0, 1, 3
Puerto 5: 2, 8, 1, 0, 3
Puerto 6: 2, 8, 0, 1, 3
Puerto 7: 2, 8, 1, 0, 3
Puerto 8: 2, 102, 0, 3
Puerto 9: 2, 8, 0, 1, 3
Puerto 10: 2, 8, 1, 1, 3
Puerto 11: 2, 8, 1, 1, 3
Puerto 12: 2, 101, 0, 3
Puerto 13: 2, 8, 1, 0, 3
Puerto 14: 2, 8, 0, 1, 3
Puerto 15: 2, 8, 1, 0, 3
Puerto 16: 2, 8, 0, 1, 3
Puerto 17: 2, 8, 1, 0, 3
Puerto 18: 2, 8, 0, 1, 3
Puerto 19: 2, 8, 1, 0, 3
Puerto 20: 2, 8, 0, 1, 3
Puerto 21: 2, 8, 1, 0, 3
Puerto 22: 2, 8, 0, 1, 3
Puerto 23: 2, 8, 1, 0, 3
Caso de Prueba 3
El objetivo de este caso de prueba es mostrar que al volver a una rutina que haba
completado un slot de tiempo el contexto es salvado correctamente. Para este caso
fueron definidas dos rutinas:
El procedimiento recursivo factRec que calcula el factorial de un nmero entre
0 y 9 recibido en AX. Esta rutina utiliza el stack y modifica registros.
La rutina1 que simplemente incrementa la posicin de memoria ds:[40]
Para que en este caso llegue a actuar el gestor y ceder el procesador a la rutina1 y as poder
observar que el contexto era salvado correctamente fue necesario definir slotTiempo EQU 4.
16
.code
cli
mov ds:[50], 0xFFFF
mov byte ptr ds:[54], 0
mov ds:[56], 0xFFFE
mov AX, segment factRec
mov BX, offset factRec
sti
int 100
cli
mov ax, segment rutina1
mov bx, offset rutina1
sti
int 100
int 103
push dx
push cx
push ax
mov cx,ax ; en cx copio idrutina
;_____________________________IMPRIME EN PUERTO______________________
MOV DX, ds:[70]
IN AX,DX
MOV AX, 0x0002 ; <STX>
OUT DX, AX
MOV AX, 0x0000 ; interrupcion 0
OUT DX, AX
MOV AX, 0x0000 ; idrutina entra
OUT DX, AX
MOV AX, 0x0003 ; <ETX>
OUT DX, AX
inc word ptr ds:[70]
;_____________________________________________________________________________
____
pop ax
pop cx
pop dx
mov byte ptr ds:[60],1
mov bp, 100
mov sp, 100
mov ax, 9
; Procedimiento RECURSIVO para calcular el factorial de un nmero entre 0 y 9
recibido en AX.
; El resultado se devuelve en DX::AX.
factRec proc
cmp ax, 0
jbe paso_base_factRec
push bx
17
push ax
dec ax
call factRec
pop bx
mul bx
pop bx
jmp fin_factRec
paso_base_factRec:
mov ax, 1
fin_factRec:
ret
factRec endp
rutina1 proc
mov byte ptr ds:[60],1 ; -----------------------ACA EMPIEZA EL PROC 1---------
---------------------------
mov byte ptr ds:[40],1
whileRutina1:
inc byte ptr ds:[40]
jmp whileRutina1
ret
rutina1 endp
Comenzamos nuestro caso agregando al sistema y arrancando las rutinas. Luego
comienza a ejecutarse factRec. Cuando termina de ejecutarse el primer slot de tiempo
el stack, flags, y registros se encuentran como indica la siguiente imagen:
Como podemos observar la instruccin que se ejecutara antes de que interrumpa el
timer es pop bx, por lo tanto, el stack al volver tendra un elemento menos y el valor
18
de bx seria 0x0008. Luego el procesador es cedido a travs del timer a rutina1 que
ejecuta un slot de tiempo, salva contexto y recupera el de factRec como podemos
observar.
19
Mejoras a futuro:
En el vector de rutinas se desplaza cada 2 bytes para guardar informacin, dejando
entre medio de cada byte un byte de memoria sin utilizar. De esta manera se est
desperdiciando memoria. Por lo tanto una futura mejora sera guardar la informacin
cada un byte. Lo mismo sucede con las variables definidas.
20
Referencias:
- EVA
- MANUAL ARQUISIM
- MATERIAL DEL CURSO.
-PLANIFICACIN ROUND-ROBIN. HTTPS://[Link]/WIKI/PLANIFICACI%C3%B3N_ROUND-ROBIN
21