Simuproc Completo

Universidad Nacional de la Matanza SimuProcIntroducción a la Informática

SimuProc 1.4.2.0

INDICE

1. PARTE TEORICA...............................................................................................................................2

1.1 Introducción....................................................................................................................................2

1.2 Programar usando SIMUPROC.....................................................................................................2

1.3 Componentes del SIMUPROC.......................................................................................................2

1.3.1 Memoria.....................................................................................................................................2

1.3.2 Registros....................................................................................................................................3

1.3.2.1 Registros generales............................................................................................................3

1.3.2.2 Registros Apuntadores.......................................................................................................3

1.3.2.3 Registros de Pila.................................................................................................................3

1.3.2.4 Registros de Control (Flags)...............................................................................................4

1.4 Características del Simulador.......................................................................................................4

1.4.1 Puertos Virtuales........................................................................................................................4

1.4.2 La Pila........................................................................................................................................5

1.4.3 Características generales..........................................................................................................5

2. PARTE PRÁCTICA............................................................................................................................6

2.2 Vista de la pantalla principal del Simuproc..................................................................................6

2.3 Conversión de números enteros entre bases..............................................................................6

2.4 Instrucciones del simulador..........................................................................................................7

2.5 Ejercicios a realizar......................................................................................................................10

2.5.1 Instrucciones básicas y utilización de datos previamente cargados en memoria...................10

2.5.2 Instrucciones básicas, se hace uso de datos ingresados desde el teclado............................10

2.5.3 Uso de saltos – Inicialización de posiciones de memoria........................................................11

2.5.4 Generación de sonido..............................................................................................................12

3. Preguntas más frecuentes................................................................................................................12

Ing. Larisa Toro - Ing. Rocío Andrea Rodríguez Página 1 de 11


1. PARTE TEORICA

1.1 Introducción

SimuProc es un Simulador de un “Procesador Hipotético” con el cual tiene por objetivo el aprendizaje de las nociones básicas para empezar a programar en lenguaje ensamblador, en el cual puede observar todo el proceso interno de ejecución del programa a través de cada ciclo del procesador.

El simulador incluye:

Un Editor con resaltador de sintaxis para escribir programas más fácilmente.

Un conversor de bases (para hacer pasajes de una base origen a otra base destino, soportando

todas las bases desde base2 a base36).

Conversión de números de punto flotante de decimal a IEEE 754 y viceversa

1.2 Programar usando SIMUPROC

El simulador solo reconoce lenguaje ensamblador (assembler1); por lo tanto para ejecutar programas en el simulador, se deben escribirlos primero en este lenguaje.

Luego de tener el programa ya en lenguaje ensamblador se carga en el simulador. Para ello existen tres alternativas:

1. Se puede cargar desde un archivo

2. Usando el Editor interno

3. Ingresando las instrucciones manualmente.

La utilización del programa es muy sencilla, sólo debe crear el programa en ensamblador e insertarlo al SimuProc mediante un archivo de texto (o manualmente). Luego él mismo se encarga de almacenar ese proyecto en un archivo .SMP para futuras necesidades sin tener que volver a escribir el programa nuevamente. Se pueden ingresar instrucciones manualmente desde la ventana principal, pero la manera mas fácil es hacerlo desde el editor.

Se accede a los Editores presionando el botón Editor en la barra de herramientas. En el panel derecho (Editor 2) puede escribir el programa, las instrucciones serán resaltadas; puede presionar el botón derecho del Mouse en este editor para acceder a más opciones.

1.3 Componentes del SIMUPROC

1.3.1 Memoria

La Memoria es el dispositivo que almacena toda la información del programa que se ejecuta, tanto datos como instrucciones. Esta en realidad no es parte del procesador, sino que es un dispositivo a parte al que el procesador accede para ir leyendo las instrucciones y datos del programa.

La capacidad de la memoria Simulada es de 4096 posiciones de 16 bits cada una: desde 0 hasta 4095 en decimal (en hexadecimal: desde 000 hasta FFF).

1 El assembler es un lenguaje de programación de bajo nivel.



Esta memoria es suficiente para ejecutar gran variedad de simples y complejos programas.

El simulador trabaja con constantes y variables en binario y direcciones (posiciones de memoria) en Hexadecimal.

1.3.2 Registros

Este Procesador consta de 3 registros de propósito general, AX, BX y CX cada uno con 16 bits de capacidad, registros apuntadores, registros de pila y registros de control.

1.3.2.1 Registros generales

Los registros generales del procesador se usan para almacenar información de uso rápido, ya que se accede a ellos a una velocidad mucho más alta que la memoria. En ellos se pueden almacenar direcciones de memoria a las que se va a acceder a lo largo de la ejecución del programa, o variables que se deseen utilizar.

1.3.2.2 Registros Apuntadores

PC ó IP: Program Counter o Instruction Pointer. Contiene la dirección de memoria de la próxima instrucción a ejecutar y es incrementado en cada nueva instrucción.

MAR: Memory Address Register (Registro de Dirección de Memoria). Es el registro en el que se almacena la dirección de memoria a la que se quiere acceder.

MDR: Memory Data Register o Memory Buffer Register. Es un registro intermedio en el que se almacenan los datos que se escriben o leen de memoria. En el caso de una lectura, se pone en el MAR la dirección y se activa la señal de leer, obteniendo en el MDR el dato buscado. En el caso de una escritura, se pone en el MAR la dirección y en el MDR el dato a escribir en memoria, después se activa la señal de escribir, de esta forma almacenamos en memoria el dato.

IR: Instruction Register. En este registro se introduce la instrucción a ejecutar, después de haberla leído de memoria accediendo a ella mediante la dirección señalada en el PC; El contenido de este registro se puede dividir en código de operación (el código que señala la operación que se realizará) y operandos. Puede haber 2 operandos o sólo uno. Acá es donde se decodifica e interpreta la instrucción; así: se descompone la instrucción leída de forma que se pueda saber cual es la operación que se desea realizar y cuales son los operandos, en su caso, o el desplazamiento en caso de que se trate de una instrucción de bifurcación.

1.3.2.3 Registros de Pila

BP: Base Pointer (Puntero de base de la pila.) El valor de por defecto es F80. Este puede cambiarse desde un programa, asignándole otra dirección de memoria con la instrucción MOV.

Mientras se ejecuta el programa se puede visualizar en una barra de porcentaje el uso de la pila.

SP : Stack Pointer (Puntero de la pila). Indica la próxima dirección de la pila que esta disponible, es decir, apunta a la cima de la pila. Este valor se cambia automáticamente cuando se usan las instrucciones PUSH ó POP.

1.3.2.4 Registros de Control (Flags)



Estos registros se usan para poder controlar el comportamiento de un programa; se activan después de cada operación según sea el resultado de la instrucción ejecutada.

Zero flag: se vuelve 1 si el resultado de la ultima operación = 0.

Negative ó Sign flag: Se vuelve 1 si el resultado de la ultima operación es igual a un numero negativo.

Carry flag: se activa cuando la operación realizada ha producido un acarreo.

Overflow flag: se activa cuando la operación produjo desbordamiento (overflow), es decir, el resultado ocupaba más de los 16 bits que caben en un registro.

Estos flags se usan principalmente en instrucciones de bifurcación (por ejemplo, si queremos que, en caso de que el resultado de la última operación fuera cero, el programa se salte varias de las instrucciones siguientes, comprobamos el flag cero y si está activo el programa salta, esto se consigue con la instrucción JEQ).

1.4 Características del Simulador

Editor Interno : Es una herramienta usada para escribir los programas mas fácilmente. Permite: deshacer, rehacer, desplazar o tabular el código seleccionado.

Modificador de Memoria : Se utiliza para inicializar las variables y/o constantes del programa en ciertas posiciones de memoria cuando lo escribe. También puede modificar posiciones de memoria en cualquier momento, ya sea antes ó durante la ejecución de un programa.

Conversor de Bases : Dispone un conversor de bases para realizar conversiones de una base a cualquier otra, soporta desde base2 a base36. También permite la conversión entre números de punto flotante y IEEE 754.

Estadísticas : El simulador constantemente le estará mostrando las estadísticas del programa en ejecución, como por ejemplo: el número de instrucciones ejecutadas, que clase de instrucciones y la velocidad de la simulación.

Vigilante de Memoria: Dispone de un vigilante de memoria con el cual se pueden observar algunas variables en las posiciones de memoria. Posee un historial que muestra los últimos 5 valores de las posiciones vigiladas.

Dispositivos Virtuales: Cada computadora utiliza periféricos para conectarse con el mundo exterior. SimuProc también dispone unos dispositivos de E/S simulados. Estos están conectados a unos puertos virtuales los cuales pueden ser accedidos con las instrucciones In y Out dependiendo del tipo de dispositivo.

1.4.1 Puertos Virtuales

Puerto 1: Teclado y Pantalla. El teclado es usado únicamente para solicitarle al usuario que ingrese un numero de 32 bits. Por pantalla podrán visualizarse resultados.

Puerto 8 : RelojLee los segundos del sistema, retorna un número en binario (entre 0 y 59) al registro especificado. Permite generar números aleatorios.



Puerto 9: SwitchesEste dispositivo, consiste de 16 switches en fila enumerados de 0 a 15. Cualquier switch puede ser encendido resultando un “1” lógico correspondiente al bit del switch.

Puerto 13: PC-SpeakerGenera sonidos a través del altavoz de tu PC. Para generar un sonido necesita dar la frecuencia y la duración en milisegundos. La frecuencia debe ser entre 7Hz y 32767Hz. La frecuencia es leída del registro especificado en la instrucción, y la duración es leída del registro BX.

1.4.2 La Pila

La pila de este simulador es simplemente un conjunto de datos que se almacenan en una zona de memoria, del tipo LIFO (Last In- First Out = Ultimo en entrar - Primero en salir).

La Pila es un buffer usualmente implementado como un bloque de n bytes o words consecutivos. En este simulador cada posición de memoria es de 16 bits.

Usos para la pila: La pila se utiliza para pasar variables entre funciones y para almacenar variables locales.

El programador es el responsable de reservar el espacio apropiado para la pila. Un problema con las pilas es que el programador las puede hacer muy pequeñas y puede que ocurra un stack overflow o desbordamiento de pila si se esta intentando usar la instrucción PUSH para enviar algo cuando ya la pila esta llena; o stack underflow si se usa la instrucción POP para leer la pila estando la misma vacía.

Por cada PUSH debe de haber luego un POP. Cuando un programa o función termina su ejecución la pila debe quedar como estaba antes de que este se ejecutara, sino hay errores en este.

1.4.3 Características generales

La velocidad de Simulación puede ser cambiada en cualquier momento y se puede apagar la animación para una ejecución más rápida. Puede observarse el acceso en memoria de las instrucciones y/o variables a medida que se ejecuta la simulación.

Al ejecutarse el Simulador este chequea que Windows este usando fuentes pequeñas y que la resolución sea como mínimo de 800x600, en otro caso sacara un dialogo para cambiarla si el usuario desea.

Hay dos Barras de Porcentaje que muestran el porcentaje de uso de la memoria simulada y porcentaje de uso del espacio reservado para la pila en ese momento.

A los Registros de control (flags) se les puede dar doble clic para hacer un cambio forzado de estos en caso de sea necesario depurar un programa. También si hace clic con el botón derecho del mouse saldrá un menú para seleccionar que flag se desea activar ó desactivar.

Para cargar programas en el simulador se pueden tipear las instrucciones manualmente por la interfaz del programa o puede abrir varios tipos de archivos:

.SMP que son los creados por este mismo cuando se salvan

.TXT

.ASM (que son compatibles con la versión anterior de este simulador)

Recuerde que también se puede usar el editor Interno.



2. PARTE PRÁCTICA

2.2 Vista de la pantalla principal del Simuproc

A continuación se muestra la pantalla principal del simulador en donde se han hecho aclaraciones básicas sobre el contenido de la misma. Haciendo referencia a lo comentado en la parte teórica de esta guía:

2.3 Conversión de números enteros entre bases.

Vienen predefinidas las bases: Decimal Octal Binario Hexadecimal


CeroNegativoCarryOverflow

Área de Memoria.Haciendo doble clic se accede a esta pantalla de codificación.

Muestra el contenido del: PC: Contador de Programa. MAR: Registro de Direcciones de Memoria (Memory Address Register).MBR ó MDR: Registro Buffer de Memoria. (Memory Data Register o Memory Buffer Register).IR: Registro Índice. (Instruction Register).

Permite hacer el seguimiento paso a paso visualizando el contenido de los registros.Además comenta en esta barra que está haciendo la CPU en cada instante (para ello debe ingresarse un programa y hacer clic en el botón “Ejecutar”).La velocidad de la animación para el seguimiento del programa debe ser variada por el usuario de modo que pueda leer sin inconveniente los comentarios y visualizar los cambios de los contenidos de los registros.

Permite seleccionar la instrucción.

En este espacio vacío aparecen en rojo los mensajes de errores que se presentan en tiempo de ejecución

Muestra el mnemónico ó no, haciendo clic es posible activar o desactivar esta opción


2.4 Instrucciones del simulador

A continuación se muestran ordenadas alfabéticamente las instrucciones que incluye el simulador (el número antepuesto indica el orden en que aparecen ubicadas en el programa):

20 - ADD [mem]: Sumar: AX = AX + el contenido de la dirección de memoria

60 - ADDF [mem]: Suma números de 32 bits: En BX y AX queda el resultado de la suma de estos más el contenido de [mem] y mem+1

11 - AND [dest,orig]: Y lógico, hace un Y lógico entre todos los bits de los dos operandos escribiendo el resultado en el destino. Los parámetros pueden ser direcciones de memoria o Registros.

04 - CLA: Hace AX = 0

25 - CLC: Limpia el Carry Flag. C = 0

27 - CMC: Complementa (invierte) el Carry Flag. Si C = 1 vuelve C = 0 y viceversa.

32 - CMP [mem]: Compara AX con [mem], si AX es mayor, Z=0 N=0, si es igual Z=1 N=0, si es menor Z=0 N=1

09 - DEC [dest]: Decremento en 1 el destino especificado (Si el destino queda = 0, se vuelve Z = 1)

23 - DIV [mem]: Dividir: AX = AX / el contenido de la dirección de memoria, BX=AX % el contenido de la dir de memoria (BX = modulo o residuo).

63 - DIVF [mem]: Division: BX y AX = BX y AX / [mem]y mem+1, en CX queda el residuo de la division en entero de 16 bits

41 - EAP: Escribe en Pantalla el contenido del registro AX

65 - FTOI: Conversión de Real a Entero: Convierte un número Real(32bits) a su equivalente en entero BX y AX en un entero (16bits), el Resultado queda en AX. Los registros de control cambian de acuerdo al numero convertido: "Z" si el numero es cero, "N" si el numero es negativo, "O" si el numero real es mayor de 65535

99 – HLT: Terminar Programa (todo programa lleva esta instrucción para indicarle al simulador que el programa ha terminado su ejecución)

80 - IN [registro,Puerto]: Lleva al Registro el valor retornado por el puerto especificado

08 - INC [dest]: Incrementa en 1 el destino especificado, el parámetro puede ser una dirección de memoria o un registro.

64 – ITOF: Conversión de Entero a Real: Convierte un número entero (16bits) almacenado en AX al mismo número pero representado en Real IEEE754(32bits), el Resultado de la conversión queda en BX (bits mas significativos) y AX. Los registros de control cambian de acuerdo al numero convertido: "Z" si el número es cero, "N" si el numero es negativo.

35 - JC [mem]: Saltar si el Carry Flag esta activado. Si C = 1, PC = contenido de memoria

31 - JEQ [mem]: Saltar si son iguales Si Z = 1, PC = contenido de la memoria.


Se pueden elegir dos bases para ver cual sería la conversión al elegir la base aparecen los símbolos que posee dicha base


34 - JMA [mem]: Saltar si es Mayor. Si Z = 0 y N = 0, PC = contenido de memoria.

33 - JME [mem]: Saltar si es Menor. Si N = 1, PC = contenido de la memoria

30 - JMP [mem]: Salto incondicional. PC = dirección de memoria donde esta la siguiente instrucción a ejecutar"

36 - JNC [mem]: Saltar si el Carry Flag no esta activado. Si C = 0, PC = contenido de memoria

39 - JNE [mem]: Saltar si no son iguales. Si Z = 0, PC = contenido de memoria

38 - JNO [mem]: Saltar si el Overflow Flag no esta activado. Si O = 0, PC = contenido de memoria

37 - JO [mem]: Saltar si el Overflow Flag esta Activado

01 - LDA [mem]: Cargue en AX el contenido de la dirección de Memoria especificada. (hay casos donde es mejor usar MOV si se desea pasar datos sin tener que pasarlos por AX)

50 - LDB [mem]: La instrucción carga en AX el contenido de memoria almacenado en [mem] + BX

55 - LDF [mem]: Carga en BX y AX un numero de 32 bits (IEEE) que esta almacenado en la dir [mem] y mem+1. En BX quedan los digitos mas Significativos

40 – LDT: Lee un valor del Teclado y lo lleva al registro AX

29 - LOOP [mem]: Decrementa CX y salta a la Pos de memoria si CX no es cero.

10 - MOV [dest,orig]: Copia el valor almacenado en el origen al destino. El destino y/o origen pueden ser registros o direcciones de memoria o combinación de estos.

42 – MSG: Muestra un mensaje en pantalla

22 - MUL [mem]: Multiplicar: AX = AX * el contenido de la dirección de memoria. (Si el número resultante supera su longitud en binario de 16 bits, este resultado se parte almacenando los bits más significativos en el Registro BX.)

62 - MULF [mem]: Multiplicación: BX y AX = BX y AX * [mem]y mem+1

90 – NOP: Esta operación no hace nada.

12 - NOT [destino]: NO lógico, invierte los bits del operando formando el complemento del primero.

13 - OR [dest,orig]: O inclusive lógico, todo bit activo en cualquiera de los operándoos será activado en el destino

81 - OUT puerto,registro: Escribe en el puerto especificado, el valor del registro

07 - POP [registro]: Trae de la Pila el último valor llevado por PUSH (indicado por el registro SP) y lo almacena en el registro especificado.

06 - PUSH [registro]: Envía el valor del registro especificado a la pila

15 - ROL [dest,veces]: Rota los bits a la izquierda las veces especificadas(en decimal), los bits que salen por la izquierda re-entran por la Derecha. En el Carry Flag queda el último bit rotado.

16 - ROR [dest,veces]: Rota los bits a la derecha las veces especificadas(en decimal), los Bits que salen por la derecha re-entran por la izquierda. El Carry Flag guarda el último bit rotado.

17 - SHL [dest,veces]: Desplaza los bits a la izquierda el numero de veces especificado(en decimal), agregando ceros a la derecha, el Carry Flag guarda ultimo bit desplazado.

18 - SHR [dest,veces]: Desplaza los bits a la Derecha el numero de veces especificado(en decimal), agregando ceros a la izquierda, el Carry Flag guarda ultimo bit desplazado.

02 - STA [mem]: Guarde el contenido de AX en la dirección de Memoria especificada

51 - STB [mem]: guarda el contenido de AX en la dirección [mem] + BX

26 – STC: Pone el Carry Flag. C = 1

56 - STF [mem]: Guarda en [mem] y mem+1 el contenido de BX y AX

21 - SUB [mem]: Restar: AX = AX - el contenido de la dirección de memoria

61 - SUBF [mem]: Resta el numero de 32 bits: BX y AX = BX y AX - [mem] y mem+1

03 - XAB: Intercambia los valores de los registros AX y BX (Esta instrucción no necesita parámetros.)

14 - XOR [dest,orig]:O exclusivo, realiza un O exclusivo entre los operándos y almacena el resultado en destino.



2.5 Ejercicios a realizar

A continuación se presentan una serie de ejercicios de distintos niveles de complejidad.

2.5.1 Instrucciones básicas y utilización de datos previamente cargados en memoria

Cargar las seis instrucciones que se muestran a continuación desde la dirección 000, hasta la 005.

Luego ingresar en las posiciones de memoria 00E y 00F los datos que se muestran a continuación

¿Qué hace el programa?

RESTA

¿Con qué valor queda la posición 00A?

003

__________________________________________________

¿Qué se muestra por pantalla?

0

__________________________________________________

__________________________________________________

__________________________________________________

2.5.2 Instrucciones básicas, se hace uso de datos ingresados desde el teclado

Cargar las siete instrucciones que se muestran a continuación desde la dirección 000, hasta la 006.

¿Qué resultado muestra en pantalla si los datos ingresados son:?Primer Dato Segundo Dato Resultado

2 6 4

10 2 -8

9 3 -6

3 9 6

20 2

¿Qué hace el programa? RESTA EN POSITIVO

________________________________________________________________

________________________________________________________________

________________________________________________________________

2.5.3 Uso de saltos – Inicialización de posiciones de memoria



Desde el editor del SIMUPROC puede cargarse directamente las instrucciones del programa, este procedimiento es menos amigable que cargar las instrucciones desde la pantalla principal. A continuación se muestra un programa que eleva un número ingresado por teclado a una potencia mayor a cero ingresada también por teclado.

Escriba al lado de cada instrucción que acción se está realizando:DIRECCION DE MEMORIA DE LA INSTRUCCION

ACCION QUE REALIZA

000 CLA AX=0001 INC AX002 STA 014003 LDT004 STA 012005 LDT006 STA 013007 LDA 014008 MUL 012009 STA 01400A DEC 01300B JNE 800C MSG00D EAP00E HLT

2.5.4 Generación de sonido

Para generar un Sonido se necesita dar la frecuencia y la duración en milisegundos.


1º Paso: Se puede escribir el programa en el editor de texto.

2º Paso: Se ve el programa cargado en cada posición de memoria (igual que como se vería en la pantalla principal salvando los carteles a mostrar por pantalla)

3º Paso: Al hacer click en enviar a memoria se cargan las instrucciones en el área de memoria de la pantalla principal del simulador.


- La frecuencia debe ser entre 7Hz y 32767Hz (frecuencias menores son tomadas por defecto dentro del umbral mínimo) y es leída del registro especificado en la instrucción.

- La duración es leída del registro BX.

Ejemplo: Supongamos que AX = 101000101000 y BX = 111110100OUT 13,AX

Produce un sonido de 2600Hz durante 500 ms

Instrucciones cargadas en las direcciones:

Dirección 000: Carga en AX el contenido de la posición de memoria: 00E.

Dirección 001: Copia el valor almacenado en el origen al destino: El contenido de AX, en BX (es decir BX se carga con el contenido de AX que en la instrucción anterior se le cargo el contenido de la posición 00E. De esta manera BX=111110100).

Dirección 002: Carga en AX el contenido de la dirección de memoria: 00F (es decir que AX=101000101000).

Dirección 003: Se genera, por el speaker (parlante interno) de la computadora, el sonido con la frecuencia establecida en AX (la duración del sonido se toma por defecto del registro BX). “Cuanto mayor es la frecuencia más agudo es el sonido, por lo que cuanto menor es la frecuencia más grave es el sonido”

Dirección 004: Fin de programa

3. PREGUNTAS MAS FRECUENTES

1. ¿Cómo puedo trabajar con números no enteros (de punto flotante)? A partir de la versión 1.4 ya es posible hacer operaciones con estos números usando las instrucciones ADDF SUBF MULF y DIVF, para llevar los números de registros a memoria y viceversa usando LDF y STF, y para mostrar estos en pantalla usando el puerto 1 con las instrucciones IN y OUT.

2. ¿Como trabajar con Números de mas de 16 bits (mayores de 65535)? Con las instrucciones aritméticas para números flotantes, puedes también trabajar con enteros entre -2147483647 y 2147483647.

3. ¿Muchas de las instrucciones que manejas no las he utilizado, podrías proporcionarme información de las instrucciones? El 90% de las instrucciones son de un procesador Intel, las otras son para abreviar otras instrucciones mas complicadas como interactuar con el usuario para pedir datos de entrada o escribirlos en pantalla.


Simuproc Completo

Documents

Transcript of Simuproc Completo