REPORTE

INTEGRANTES
ACOSTA RIOS MIGUEL ANGEL 14320893
PRIMERA PRACTICA
CERVANTES VELAZQUEZ – SUMA IMPARES
ANA RUTH 14320928
MEZA LOZANO JENNIFER ROXANA 15320169
MORALES DURAN JUAN 14321034
RESUMEN (ABSTRACT)

WinDLX (WindowsDeLuXesimulator) simulador del pipeline del procesador DLX

desarrollado en el Departamento de Diseño-VLSI de la Universidad Tecnológica
de Viena. Permite el procesamiento de programas escritos en ensamblador de
DLX, mostrando toda la información relevante de la CPU:
1. Estado del pipeline
2. Banco de registros
3. Entrada/Salida
4. Memoria
5. Estadísticas, etc.
Posibilita la modificación de la estructura y tiempos de latencia del pipeline de
la CPU y del tamaño de la memoria, así como del contenido de otros de sus
componentes mientras se desarrolla la ejecución de un programa. DLX
(Pronunciado “DeLuxe”). La arquitectura del conjunto de instrucciones DLX fue
presentada por primera vez en la obra “Computer Architecture: A Quantitative
Approach” de Jonh Hennessy y Dave Patterson. Según sus autores, DLX es el
segundo computador poliinsaturado del mundo. Se ha elegido la arquitectura
del DLX sobre la base de observaciones de las primitivas utilizadas con más
frecuencia en los programas. Las instrucciones más sofisticadas (y menos
críticas en cuanto a rapidez) son implementadas por software mediante la
ejecución de instrucciones múltiples.
INDICE

Contenido
RESUMEN (ABSTRACT).................................................................................................................1
INDICE..........................................................................................................................................2
INTRODUCCIÓN............................................................................................................................3
ASPECTOS TEÓRICOS....................................................................................................................4
DESARROLLO PRÁCTICO...............................................................................................................8
RESULTADOS...............................................................................................................................13
CONCLUSIÓN..............................................................................................................................14
BIBLIOGRAFÍA.............................................................................................................................15
APÉNDICES.................................................................................................................................16
ANEXOS......................................................................................................................................17
INTRODUCCIÓN

En esta práctica manejaremos un simulador (WinDLX, de 32 bits, el cual fue

ejecutado en una máquina virtual con Windows 7 de 32 bits igualmente y el
cual puede ser descargado en la siguiente página:
http://electro.fisica.unlp.edu.ar/arq/downloads/Software/WinDLX/windlx.html)
Hay que tener en cuenta que el juego de instrucciones de los procesadores
RISC está orientado a la sencillez para que el encadenamiento sea muy
efectivo, de ahí que las instrucciones de que suele disponer son muy simples, y
en esto difieren de las de los procesadores CISC (ej. familia x86 o 68000). En
esta práctica se pretende estudiar el comportamiento de un procesador
segmentado, comprobar el efecto de los bloqueos de datos y control sobre las
prestaciones, así como evaluar algunas técnicas para reducir estos bloqueos.
El procesador DLX ha sido diseñado bajo la filosofía de diseño RISC cuyos
principios se pueden concretar en los siguientes puntos: · Arquitectura de
carga-almacenamiento.
· Repertorio de instrucciones sencillo.
· Diseño de la segmentación eficiente.
· Fácil implementación hardware de las instrucciones: Instrucciones de
longitud fija y pocos modos de direccionamiento.
ASPECTOS TEÓRICOS

WinDlx
Este software de simulación permite el procesamiento de programas escritos
en ensamblador de DLX, mostrando toda la información relevante de la CPU
(estado del pipeline, banco de registros, entrada/salida, memoria, estadísticas).
Su versatilidad posibilita la modificación de la estructura y tiempos de latencia
del pipeline de la CPU y del tamaño de la memoria, así como del contenido de
otros de sus componentes mientras se desarrolla la ejecución de un programa.
Lenguaje Ensamblador
El lenguaje ensamblador, o assembler (en inglés assembly language y la
abreviación asm), es un lenguaje de programación de bajo nivel. Consiste en
un conjunto de mnemónicos que representan instrucciones básicas para
los computadores, microprocesadores, microcontroladores y otros circuitos
integrados programables. Implementa una representación simbólica de
los códigos de máquina binarios y otras constantes necesarias para programar
una arquitectura de procesador y constituye la representación más directa
del código máquina específico para cada arquitectura legible por un
programador. Cada arquitectura de procesador tiene su propio lenguaje
ensamblador que usualmente es definida por el fabricante de hardware, y está
basada en los mnemónicos que simbolizan los pasos de procesamiento
(las instrucciones), los registros del procesador, las posiciones de memoria y
otras características del lenguaje. Un lenguaje ensamblador es por lo tanto
específico de cierta arquitectura de computador física (o virtual).
Mnemónico
Un mnemónico o nemónico es una palabra que sustituye a un código de
operación (lenguaje de máquina), con lo cual resulta más fácil la programación,
es de aquí de donde se aplica el concepto de lenguaje ensamblador.
Un ejemplo común de mnemónico es la instrucción MOV (mover), que le indica
al microprocesador que debe asignar datos de un lugar a otro. El
microprocesador no entiende palabras, sino números binarios, por lo que es
necesaria la traducción del término mnemónico a código objeto.
Suma o adición

La suma o adición es la operación matemática que resulta al

reunir en unas solas varias cantidades.

Los números que se suman se llaman sumandos y el

resultado suma o total.
Para su notación se emplea entre los sumandos el signo + que
se lee "más".

La operación de sumar

En la práctica de la suma podemos distinguir tres casos:

1º Sumar dos números de una sola cifra

La suma de dos números de una sola cifra se halla

mentalmente, una vez que se ha aprendido la tabla de la
suma:
2º Sumar un número de una cifra y otro cualquiera

Se agregan las unidades del segundo número a las del primero

y, caso que no pasen de nueve, los otros números del primer
sumando no varían.

533 + 5 = 538

Si la suma pasa a la de 9, se añade una unidad al número que

señala las decenas, en el primer sumando.

533 + 9 = 542

3º Sumar números de varias cifras

Se colocan los números unos debajo de otros, de modo que

las unidades queden debajo de las unidades, la decenas
debajo o de las decenas, etc.

Se suman las unidades de la primera columna, si es un

número de una cifra, se escribe al pie de la columna.
Y si tiene más de una cifra, se escribe al pie de la columna
únicamente la cifra de las unidades, añadiendo las decenas a
la columna siguiente, procediendo a continuación de igual
forma.

Números impares

Un núm ero e s im par si e s no e s múl tip lo de do s.

N úm ero im pa r = 2 · n − 1 . n es cualqu ie r núme ro ente r o .

N úm ero im pa r = 2 · n + 1 . n es cualqu ie r núme ro ente r o .

Lo s núm ero s im par e s te r mina n e n 1, 3, 5, 7, 9 .

Propieda des de los números impa res

L a suma de un núm ero pa r e im pa r e s un núm er o im par .

L a suma de do s núm er o s im pa r es es un núm ero pa r .

DESARROLLO PRÁCTICO

Código

.data

Prompt: .asciiz "Total de números impares a sumar >1: "

PrintfFormat: .asciiz "Total = %g\n\n"

.align 2

PrintfPar: .word PrintfFormat

PrintfValue: .space 8

.text

.global main

main:

;*** Read value from stdin into R1

addi r1,r0,Prompt

jal InputUnsigned

;*** init values

movi2fp f10,r1 ;R1 -> D0 D0..Count register

cvti2d f4,f10

addi r2,r0,1 ;1 -> D2 D2..result

movi2fp f11,r2

cvti2d f2,f11

movd f0,f2 ;1-> D4 D4..Constant 1

cvti2d f12,f2

;*** Break loop if D0 = 1

 addd f12,f12,f4

Loop: led f4,f0 ;D0<=1 ?

bfpt Finish

;*** Multiplication and next loop´

addd f2,f2,f0

addd f2,f2,f0

addd f12,f12,f2

subd f4,f4,f0

j Loop

Finish: ;*** write result to stdout

addd f12,f12,f10

sd PrintfValue,f12

addi r14,r0,PrintfPar

trap 5

;*** end

;trap 0
Ilustración 1. Abrimos nuestro programa Windlx

Ilustración 2. Abriremos la pestaña “File” y le daremos en la opción Reset all.

Ilustración 3 Nos mostrar el siguiente mensaje y le damos en aceptar

Ilustración 4 Para cargar nuestro código iremos a la pestaña de File y seleccionaremos Load Code or Data

Ilustración 5 Seleccionamos nuestro archivo de suma de números impares y tambien el archivo input el cual es
obligatorio para que nuestro código funcione

Ilustración 6 Nos aparecerá el siguiente mensaje y le daremos en Si

Ilustración 7 Nos vamos a la pestaña Execute y le daremos en Run para ejecutar nuestro código

Ilustración 8 Mensaje que nos pide el número que uno desea sumar
RESULTADOS

Ilustración 9 Pruebas de la suma de algunos números

CONCLUSIÓN

Podemos entender que el procesador DLX (pronunciado "DeLuXe") es un

procesador segmentado utilizado como ejemplo en la arquitectura de
computadora de J. Hennessy y D. Patterson: un enfoque cuantitativo.
Una vez abierta la aplicación podrá observar que aparece una ventana principal
que a su vez contiene 6 ventanas inicialmente minimizadas, mostrando cada
una de ellas diferentes aspectos relacionados con el procesador que se está
simulando.
El nombre de cada una de estas seis ventanas es:
• Registros (Register).
• Código (Code) • Pipeline.
• Diagrama de Ciclos de Reloj (Clock Cycle Diagram)
• Estadísticas (Statistics)
• Puntos de ruptura (Breakpoints)
BIBLIOGRAFÍA

https://www.uv.es/varnau/ManualDLX.pdf

http://atc2.aut.uah.es/~nacho/AII/practicas%20antiguas/Practica3.pdf
APÉNDICES

Ejemplo de suma impar en lenguaje de alto nivel c++

#include<iostream>
#include<cstdlib>

using namespace std;

int main()
{
int num, sumaPar = 0, sumaImpar = 0;

cout << "Digite numero: ";

cin >> num;

for (int i = 0 ; i <= num ; i++)

{
if (i % 2 == 0) sumaPar += i;
else
{
sumaImpar += i;

}
}

cout << "La suma de pares hasta " << num << " es de: " << sumaPar << endl;
cout << "La suma de impares hasta " << num << " es de: " << sumaImpar <<
endl;

system ("pause");

}
ANEXOS

Tabla de la suma:
Código

.data

Prompt: .asciiz "Total de números impares a sumar >1: "

PrintfFormat: .asciiz "Total = %g\n\n"

.align 2

PrintfPar: .word PrintfFormat

PrintfValue: .space 8

.text

.global main

main:

;*** Read value from stdin into R1

addi r1,r0,Prompt

jal InputUnsigned

;*** init values

movi2fp f10,r1 ;R1 -> D0 D0..Count register

cvti2d f4,f10

addi r2,r0,1 ;1 -> D2 D2..result

movi2fp f11,r2

cvti2d f2,f11

movd f0,f2 ;1-> D4 D4..Constant 1

cvti2d f12,f2

;*** Break loop if D0 = 1

addd f12,f12,f4

Loop: led f4,f0 ;D0<=1 ?

bfpt Finish
 ;*** Multiplication and next loop´

addd f2,f2,f0

addd f2,f2,f0

addd f12,f12,f2

subd f4,f4,f0

j Loop

Finish: ;*** write result to stdout

addd f12,f12,f10

sd PrintfValue,f12

addi r14,r0,PrintfPar

trap 5

;*** end

;trap 0

Resultado: