ESCUELA POLITÉCNICA NACIONAL

FACULTAD DE INGENIERÍA DE SISTEMAS

INGENIERÍA DE SISTEMAS INFORMÁTICOS Y DE COMPUTACIÓN

ESCUELA POLITÉCNICA NACIONAL

FACULTAD DE INGENIERÍA DE SISTEMAS
CARRERA DE INGENIERIA EN SISTEMAS INFORMÁTICOS Y DE COMPUTACIÓN

Laboratorio de:

Arquitectura de Computadores

Práctica No.: 6

Integrantes: Henrry Cordovillo

Tema:

Simulación de Microprocesadores

Objetivos:

 Establecer el funcionamiento de un microprocesador RISC mediante un simulador especifico.

 Establecer el funcionamiento de procesos sencillos mediante un sistema sincrónico.
 Reconocer los principales comandos y métodos del lenguaje assembler para un procesador RISC.

Marco teórico:

Simula3MS es un proyecto del grupo de Arquitectura de Computadores de la Universidad de A

Coruña. El proyecto abarca la implementación de un simulador de una arquitectura básica en sus
versiones monociclo, multiciclo y segmentado, que se pretende usar en los laboratorios de
prácticas de asignaturas que tratan la organización del computador. Actualmente cuenta con tres
opciones de simulación diferentes: entrada/salida, técnicas de salto y camino de datos. Esta última
opción permite escoger entre diferentes configuraciones del camino de datos: monociclo,
multiciclo, segmentado básico, Marcador y algoritmo de Tomasulo.

Los simuladores de los procesadores son ampliamente utilizados en docencia debido a que ofrecen
un entorno de programación menos peligroso y mejor que una máquina real porque pueden
detectar errores, ofrecer más posibilidades que un ordenador real y no modifican elementos físicos
del computador.

Simula3MS cuenta con un entorno de trabajo gráfico y de fácil manejo que permite depurar
cómodamente los programas, observar la evolución de la memoria, así como la ejecución de las
instrucciones sobre distintos caminos de datos. La presencia de las distintas implementaciones en
la misma herramienta permite observar las diferencias de ejecución de un mismo código según
cuales sean las características del procesador. Simula3MS implementa un subconjunto de
 ESCUELA POLITÉCNICA NACIONAL
FACULTAD DE INGENIERÍA DE SISTEMAS
INGENIERÍA DE SISTEMAS INFORMÁTICOS Y DE COMPUTACIÓN

instrucciones basadas en el repertorio de instrucciones del procesador MIPS R2000/R3000. Consta

de una primera parte que incluye un editor y que permite analizar sintácticamente las instrucciones
antes de pasar a observar la ejecución de las mismas. Una vez analizadas sintácticamente las
instrucciones se puede seguir la evolución del segmento de datos, así como de los registros y del
resto de elementos de la ventana de ejecución. Por otra parte, Simula3MS cuenta con un
coprocesador de punto flotante en todas sus configuraciones, e incluye dos técnicas de gestión de
entrada/salida: encuesta e interrupciones.

Intérpretes de software

Los intérpretes de software admiten un entorno de programación interactiva que alienta al usuario
a experimentar iterativamente con su definición de problema en una serie de sesiones de edición /
ejecución / evaluación. La interpretación de software en tiempo de ejecución proporciona un
entorno de programación potente y flexible, y continúa hoy como un enfoque de ejecución de
software común.

Una desventaja se produce debido a la actividad continua de traducción de texto que el intérprete
realiza en cada iteración de su ciclo de ejecución. Algunos intérpretes reducen la sobrecarga de
traducción de texto al primer tokenizar la sintaxis de las líneas de texto del programa de usuario
original en una estructura de datos especial. El ciclo principal de interpretación opera en contra de
esa estructura de datos, en lugar del texto original sin formato.

Procesamiento Monociclo

En el modelo monociclo los recursos (Memoria, ALU) deben utilizarse solo una vez por cada ciclo del
reloj. Incluso esto causa que hay veces en que estos recursos deben duplicarse. El período del reloj
se ajusta con la ruta crítica combinacional, que es la establecida por la instrucción más lenta en
completar sus transferencias, si existen instrucciones que demoran demasiado (las de punto
flotante) la frecuencia del reloj debe ajustarse a la instrucción que más tarda.

Procesamiento Multiciclo

Se tienen cinco etapas para la ejecución de instrucciones (no todas las instrucciones usan todas las
etapas):

1.-Búsqueda de la Instrucción: Lectura de Memoria de Instrucciones y cálculo de dirección de

próxima instrucción.
2.-Decodificación de la Instrucción y lectura de registros.
3.-Ejecución de operaciones y cálculo de la dirección efectiva de Memoria.
4.-Lectura de Memoria de Datos o Escritura en Memoria de Datos.
5.-Escritura en Registros.
 ESCUELA POLITÉCNICA NACIONAL
FACULTAD DE INGENIERÍA DE SISTEMAS
INGENIERÍA DE SISTEMAS INFORMÁTICOS Y DE COMPUTACIÓN

La activación de las señales que controlan las transferencias deben efectuarse asociadas a diferentes
ciclos del reloj. Para lograr esto es preciso modelar la unidad de control como una máquina
secuencial de estados finitos.

Procesamiento segmentado

Los procesamientos segmentados sirven para mejorar el rendimiento sin necesidad de duplicar
excesivamente el hardware. Presenta múltiples instrucciones solapadas, este permite mejorar La
ejecución de una instrucción pasa por varias etapas:

1. Búsqueda de Instrucción.

2. Decodificación.

3. Búsqueda de Operandos.

4. Ejecución.

5. Almacenamiento de Resultados

Desarrollo de la práctica:

Parte 1:

1. Abrir la ventana de Simula3MS

2. Editar un nuevo código en lenguaje ensamblador o cargar un fichero creado con anterioridad
en este caso un código que realiza operaciones con números flotantes que son almacenados
en un vector de 4 espacios.
 ESCUELA POLITÉCNICA NACIONAL
FACULTAD DE INGENIERÍA DE SISTEMAS
INGENIERÍA DE SISTEMAS INFORMÁTICOS Y DE COMPUTACIÓN

3. Una vez editado o cargado el fichero, el siguiente paso es ensamblarlo, para ello hay que pulsar el
botón Ensamblar. A partir de aquí hay dos posibles resultados:
 Si el código no tiene errores: Se activará el botón "Ejecutar" y podremos simular nuestro
programa
 Si el código contiene errores: Aparecerán todos ellos en el "Cuadro de errores" y se
remarcará sobre nuestro código el primer error. Es posible remarcar el resto de errores (En
caso de existir) pulsando el botón "Error siguiente".

4.- Escoger la configuración del simulador sobre la que queremos que se ejecute el código. Para ello,
en el menú Configuración tenemos tres posibles opciones. Por defecto la opción activada es el
camino de datos Monociclo con la Entrada/Salida deshabilitada.

5.- Una vez obtenido, el código correcto y configurado el simulador, se pulsa Ejecutar.
 ESCUELA POLITÉCNICA NACIONAL
FACULTAD DE INGENIERÍA DE SISTEMAS
INGENIERÍA DE SISTEMAS INFORMÁTICOS Y DE COMPUTACIÓN

6.- Finalmente tenemos acceso a la ventana en la cual se simula la ejecución.

7.- Una vez que hemos identificado todas las partes tendremos que ir pulsando sobre ciclo siguiente
hasta que lleguemos a la última orden anotando todos los cambios que se van produciendo en los
diferentes registros.
 ESCUELA POLITÉCNICA NACIONAL
FACULTAD DE INGENIERÍA DE SISTEMAS
INGENIERÍA DE SISTEMAS INFORMÁTICOS Y DE COMPUTACIÓN

Parte 2:

Realizamos los mismos pasos hechos en la parte 1 con la excepción que ahora las operaciones son
con tres flotantes y tres enteros con un vector de 8 espacios donde la respuesta se almacena en la
ultimo espacio del vector.
 ESCUELA POLITÉCNICA NACIONAL
FACULTAD DE INGENIERÍA DE SISTEMAS
INGENIERÍA DE SISTEMAS INFORMÁTICOS Y DE COMPUTACIÓN

Parte 3:
 ESCUELA POLITÉCNICA NACIONAL
FACULTAD DE INGENIERÍA DE SISTEMAS
INGENIERÍA DE SISTEMAS INFORMÁTICOS Y DE COMPUTACIÓN

Análisis de resultados:

 En el primer código vemos como guardar y como usar el programa Simula3MS

 El segundo algoritmo que utilizamos en el Simula3MS es donde hacemos una suma
de enteros vemos como los números se guardan en cada posición de los vectores y
luego los almacena, opera y vuelve a guardar.
 En el tercer algoritmo utilizado en el Simula3MS es la suma y multiplicación entre
enteros y flotantes
 En el segundo programa intentamos hacer las mismas cosas que el primero, pero fue
un poco mas complicado ya que no encontramos mucha información, pero daban el
mismo resulta
 Todos esto ejemplos tenían la misma similitud, el ensenar como trabaja los datos el
microprocesador

Conclusiones:

 Con su introducción en el programa de la asignatura Arquitectura de Computadoras se

viene observando una mejor comprensión de los contenidos relacionados con esta.
 Esta práctica es sencilla, sobre todo gracias al uso del Manual del simulador y del guion, el
cual ayuda bastante a la resolución de esta. Se basa principalmente en copiar diferentes
ejercicios del guion y tomar datos del simulador, ver el proceso de cada ciclo.
 Esta práctica fue de gran ayuda para repasar la programación en ensamblador.
 Nos permitió identificar el camino de datos del procesador y comprobar su funcionamiento
mediante el simulados SIMULA3MS y CPU-OS.
 Se pudo realizar operaciones básicas las cuales eran almacenadas en espacios de memoria
luego para ser tomadas para realizar dichas operaciones.
 ESCUELA POLITÉCNICA NACIONAL
FACULTAD DE INGENIERÍA DE SISTEMAS
INGENIERÍA DE SISTEMAS INFORMÁTICOS Y DE COMPUTACIÓN

Recomendaciones:

 Para evitar problemas de ejecución al momento de realizar las sumas, se recomienda para
iniciar introducir únicamente números flotantes.
 Es necesario realizar una lectura del manual adjunto a la práctica, para el correcto
desarrollo de la misma.
 Estar concentrados e ingresar correctamente el código del programa.
 Buscar contenido extra en internet para saber como funcionan cada uno de los programas.

Bibliografía:

http://simula3ms.des.udc.es/
http://culturacion.com/cual-es-la-funcion-del-procesador/
http://simula3ms.des.udc.es/Manual.pdf

Anexos:

ALGORITMO 1:

#programa que define un vector array_word de palabras de 4 elementos, valores 210, 240, 330, 5640
#direccion del vector se almacena en $t1, palabras se almacenan en un $sn de palabra en palabra
hay una diferencia de 4 bytes

#seccion .data
.data
#cargo el vector con los valores para el sistema directamente
array_word: .word 210,240,330,5640

#seccion principal .text

.text
.globl main
main:
#cargar la direccion del vector en t1 la=load adress
la $t1, array_word
lw $s0,0($t1)
lw $s1,4($t1)
lw $s2,8($t1)
lw $s3,12($t1)

ALGORITMO 2:
#programa que solicita valores enteros los almacena en un vector junto al resultado
#seccion .data
.data
vector: .space 16

#seccion principal
.text
.globl main
 ESCUELA POLITÉCNICA NACIONAL
FACULTAD DE INGENIERÍA DE SISTEMAS
INGENIERÍA DE SISTEMAS INFORMÁTICOS Y DE COMPUTACIÓN

main:
#cargar la direccion del vector en t0 la=load adress
la $t0, vector

#primera peticion de datos

#li=llamada del sistema que lee un numero entero
li $v0,0x00000005
syscall
#sw=almacenar el numero que ingreso en la posicion correspondiente del vector
#$v0,0($t0) =en la posicion 0 de lo que esta en t0 almacene lo que tengo en v0
sw $v0,0($t0)

#segunda peticion de datos

#li=llamada del sistema que lee un numero entero
li $v0,0x00000005
syscall
#sw=almacenar el numero que ingreso en la posicion correspondiente del vector
#$v0,0($t0) =en la posicion 0 de lo que esta en t0 almacene lo que tengo en v0
sw $v0,4($t0)

#tercera peticion de datos

#li=llamada del sistema que lee un numero entero
li $v0,0x00000005
syscall
#sw=almacenar el numero que ingreso en la posicion correspondiente del vector
#$v0,0($t0) =en la posicion 0 de lo que esta en t0 almacene lo que tengo en v0
sw $v0,8($t0)

#cargar en s0, s1, s2 los valores almacenados en el vector

#carge la posicon de t0 en s0
lw $s0,0($t0)
lw $s1,4($t0)
lw $s2,8($t0)

#operacion aritmetica
add $s1,$s0, $s1
add $s3,$s1,$s2

#almacenar el resultado de la suma

sw $s3,12($t0)

#carga del resultado en a0 en la posicion 12 de t0

lw $a0,12($t0)

#llamada al sistema para imprimir

li $v0,0x00000001
syscall

ALGORITMO3:
 ESCUELA POLITÉCNICA NACIONAL
FACULTAD DE INGENIERÍA DE SISTEMAS
INGENIERÍA DE SISTEMAS INFORMÁTICOS Y DE COMPUTACIÓN

#Programa que solicita valores flotantes los almacena en un vector junto al resultado
#seccion .data
.data
vector: .space 32
#seccion principal
.text
.globl main
main:

#cargar la direccion del vector en t0 la=load adress

la $t0, vector

#NUMEROS ENTEROS
#Peticion de primer entero
li $v0,0x00000005
syscall
sw $v0,0($t0)
#Peticion de segundo entero
li $v0,0x00000005
syscall
sw $v0,4($t0)
#Peticion de tercer entero
li $v0,0x00000005
syscall
sw $v0,8($t0)

#NUMEROS FLOTANTES
#Peticion de primer Flotante
li $v0,0x00000006
syscall
swc1 $f0,12($t0)
#Peticion de segundo flotante
li $v0,0x00000006
syscall
swc1 $f0,16($t0)
#Peticion de tercer flotante
li $v0,0x00000006
syscall
swc1 $f0,20($t0)

#CARGAR ENTEROS
#cargar en s0, s1, s2 los valores almacenados en el vector
#carge la posicon de t0 en s0
lw $s0,0($t0)
lw $s1,4($t0)
lw $s2,8($t0)
#suama
add $s1,$s0, $s1
add $s3,$s1,$s2
 ESCUELA POLITÉCNICA NACIONAL
FACULTAD DE INGENIERÍA DE SISTEMAS
INGENIERÍA DE SISTEMAS INFORMÁTICOS Y DE COMPUTACIÓN

#ctv.s.w Combierte un entero en flotante

cvt.s.w $f4, $s3

#CARGAR FLOTANTES
#cargar en f0, f1, f2 los valores almacenados en el vector
#carge la posicon de t0 en f0
lwc1 $f0,12($t0)
lwc1 $f1,16($t0)
lwc1 $f2,20($t0)

add.s $f1,$f0, $f1

add.s $f3,$f1,$f2
#Suma de Entero y Flotante
add.s $f5,$f4,$f3
swc1 $f5,24($t0)
lwc1 $f12,24($t0)
#imprimir Resultado de suma
li $v0,0x00000002
syscall
#Multiplicacion de entero y flotante
mul.s $f1,$f0, $f1
mul.s $f3,$f1,$f2
mul.s $f5,$f4,$f3
swc1 $f5,28($t0)
lwc1 $f12,28($t0)
#imprecion de Multiplicacion
li $v0,0x00000002
syscall

ALGORITMO 4:

#Programa que solicita valores flotantes los almacena en un vector junto al resultado
#seccion .data
.data
vector: .space 16
#seccion principal
.text
.globl main
main:

#cargar la direccion del vector en t0 la=load adress

la $t0, vector

#primera peticion de datos

#li=llamada del sistema que lee un numero entero
li $v0,0x00000006
syscall
#swc1=almacenar el numero que ingreso en la posicion correspondiente del vector
#$f0,0($t0) =en la posicion 0 de lo que esta en t0 almacene lo que tengo en v0
swc1 $f0,0($t0)
 ESCUELA POLITÉCNICA NACIONAL
FACULTAD DE INGENIERÍA DE SISTEMAS
INGENIERÍA DE SISTEMAS INFORMÁTICOS Y DE COMPUTACIÓN

#segunda peticion de datos

#li=llamada del sistema que lee un flotante entero
li $v0,0x00000006
syscall
#swc1=almacenar el numero que ingreso en la posicion correspondiente del vector
#$f0,0($t0) =en la posicion 0 de lo que esta en t0 almacene lo que tengo en v0
swc1 $f0,4($t0)

#tercera peticion de datos

#li=llamada del sistema que lee un numero entero
li $v0,0x00000006
syscall
#swc1=almacenar el numero que ingreso en la posicion correspondiente del vector
#$f0,0($t0) =en la posicion 0 de lo que esta en t0 almacene lo que tengo en v0
swc1 $f0,8($t0)

#cargar en f0, f1, f2 los valores almacenados en el vector

#carge la posicon de t0 en f0
lwc1 $f0,0($t0)
lwc1 $f1,4($t0)
lwc1 $f2,8($t0)

#operacion aritmetica
add.s $f1,$f0, $f1
add.s $f3,$f1,$f2

#almacenar el resultado de la suma

swc1 $f3,12($t0)

#carga del resultado en f12 en la posicion 12 de t0

lwc1 $f12,12($t0)

#llamada al sistema para imprimir

li $v0,0x00000002
syscall