Estructura de Computadores I.

Tarea 01.

02/99

a)

Escribir programa MIPS que realice:

a= (b+c-d)-e
Escoger las variables en registros. Cambiarlas a medida que efecta la simulacin, y
verificar el correcto funcionamiento.

b)
Escribir un programa en assembler MIPS, que tome el valor que est en el registro
$s0 y coloque en los registros $ti los siguientes valores: $s0*2i.
Para i entre 0 y 7.
Si, por ejemplo, en $s0 se coloca un 1, se tendrn:
$t0 = 1
$t1 = 2
$t2 = 4
$t3 = 8
$t4 = 16
$t5 = 32
$t6 = 64
$t7 = 128
Probar el programa en el simulador. Cambiando el valor de $s0.
Mediante cut and paste se puede realizar el informe.
Solucin 1.
Desarrollo a):
El programa que se utiliza es :
.text
.globl main
main:
addi $t1,$zero,0x2222
addi $t2,$zero,0x2222
addi $t3,$zero,0x1111
addi $t4,$zero,0x1111
add $t0,$t1,$t2
sub $t0,$t0,$t3
sub $t0,$t0,$t4
Donde los registros representados son: $t0 a, $t1 b, $t2 c, $t3 d, $t4 e.
Haciendo el clculo anterior en la calculadora resulta que a es igual a: 0x2222.

En la simulacin se presenta as:

R0
R1
R2
R3
R4
R5
R6
R7

(r0) = 0x00000000
(at) = 0x00000000
(v0) = 0x0000000a
(v1) = 0x00000000
(a0) = 0x00000000
(a1) = 0x7ffff000
(a2) = 0x7ffff004
(a3) = 0x00000000

General Registers
R8 (t0) = 0x00002222 R16 (s0) = 0x00000000 R24 (t8) = 0x00000000
R9 (t1) = 0x00002222 R17 (s1) = 0x00000000 R25 (t9) = 0x00000000
R10 (t2) = 0x00002222 R18 (s2) = 0x00000000 R26 (k0) = 0x00000000
R11 (t3) = 0x00001111 R19 (s3) = 0x00000000 R27 (k1) = 0x00000000
R12 (t4) = 0x00001111 R20 (s4) = 0x00000000 R28 (gp) = 0x00000000
R13 (t5) = 0x00000000 R21 (s5) = 0x00000000 R29 (sp) = 0x7fffeffc
R14 (t6) = 0x00000000 R22 (s6) = 0x00000000 R30 (s8) = 0x00000000
R15 (t7) = 0x00000000 R23 (s7) = 0x00000000 R31 (ra) = 0x0040001c

El programa ocupado queda registrado en las instrucciones del simulador como:

[0x00400020]
[0x00400024]
[0x00400028]
[0x0040002c]
[0x00400030]
[0x00400034]
[0x00400038]

0x20092222
0x200a2222
0x200b1111
0x200c1111
0x012a4020
0x010b4022
0x010c4022

addi $9, $0, 8738

addi $10, $0, 8738
addi $11, $0, 4369
addi $12, $0, 4369
add $8, $9, $10
sub $8, $8, $11
sub $8, $8, $12

; 4: addi $t1,$zero,0x2222
; 5: addi $t2,$zero,0x2222
; 6: addi $t3,$zero,0x1111
; 7: addi $t4,$zero,0x1111
; 8: add $t0,$t1,$t2
; 9: sub $t0,$t0,$t3
; 10: sub $t0,$t0,$t4

--- Ahora

si b = 2002; c = 222; d = 11; e = 110.

Haciendo el clculo anterior en la calculadora resulta que a es igual a: 0x2103.
La simulacin arroja:
R0
R1
R2
R3
R4
R5
R6
R7

(r0) = 0x00000000
(at) = 0x00000000
(v0) = 0x0000000a
(v1) = 0x00000000
(a0) = 0x00000000
(a1) = 0x7ffff000
(a2) = 0x7ffff004
(a3) = 0x00000000

General Registers
R8 (t0) = 0x00002103 R16 (s0) = 0x00000000
R9 (t1) = 0x00002002 R17 (s1) = 0x00000000
R10 (t2) = 0x00000222 R18 (s2) = 0x00000000
R11 (t3) = 0x00000011 R19 (s3) = 0x00000000
R12 (t4) = 0x00000110 R20 (s4) = 0x00000000
R13 (t5) = 0x00000000 R21 (s5) = 0x00000000
R14 (t6) = 0x00000000 R22 (s6) = 0x00000000
R15 (t7) = 0x00000000 R23 (s7) = 0x00000000

R24 (t8) = 0x00000000

R25 (t9) = 0x00000000
R26 (k0) = 0x00000000
R27 (k1) = 0x00000000
R28 (gp) = 0x00000000
R29 (sp) = 0x7fffeffc
R30 (s8) = 0x00000000
R31 (ra) = 0x0040001c

Conclusin:
Por la comparacin de los resultados hechos con calculadora y los resultados de la
simulacin del programa en Spim, se puede asegurar que el programa est funcionando
correctamente. Ya se conoci y comprob las instrucciones de suma y resta en lenguaje
assembler.

Desarrollo b):
La estructura bsica del programa a emplear es:
.text
.globl main
main:
addi $s0,$s0,2
add $t0,$zero,$s0
add $t1,$t0,$t0
add $t2,$t1,$t1
add $t3,$t2,$t2
add $t4,$t3,$t3
add $t5,$t4,$t4
add $t6,$t5,$t5
add $t7,$t6,$t6
La idea del programa es que cada registro posterior tenga el doble del valor del registro
base. Entonces si se parte con un valor 2 (Osea $s0 = 2) deben obtenerse los resultados:
$t0 = 2 = 0x2
$t1 = 4 = 0x4.
$t2 = 8 = 0x8.
$t3 = 16 = 0x10.
$t4 = 32 = 0x20.
$t5 = 64 = 0x40.
$t6 = 128 = 0x80.
$t7 = 256 = 0x100.

Haciendo la simulacin en Spim se consigue el resultado:

R0
R1
R2
R3
R4
R5
R6
R7

(r0) = 0x00000000
(at) = 0x00000000
(v0) = 0x0000000a
(v1) = 0x00000000
(a0) = 0x00000000
(a1) = 0x7ffff000
(a2) = 0x7ffff004
(a3) = 0x00000000

General Registers
R8 (t0) = 0x00000002 R16 (s0) = 0x00000002 R24 (t8) = 0x00000000
R9 (t1) = 0x00000004 R17 (s1) = 0x00000000 R25 (t9) = 0x00000000
R10 (t2) = 0x00000008 R18 (s2) = 0x00000000 R26 (k0) = 0x00000000
R11 (t3) = 0x00000010 R19 (s3) = 0x00000000 R27 (k1) = 0x00000000
R12 (t4) = 0x00000020 R20 (s4) = 0x00000000 R28 (gp) = 0x00000000
R13 (t5) = 0x00000040 R21 (s5) = 0x00000000 R29 (sp) = 0x7fffeffc
R14 (t6) = 0x00000080 R22 (s6) = 0x00000000 R30 (s8) = 0x00000000
R15 (t7) = 0x00000100 R23 (s7) = 0x00000000 R31 (ra) = 0x0040001c

El programa ocupado queda registrado en las instrucciones del simulador como:

[0x00400020]
[0x00400024]
[0x00400028]
[0x0040002c]
[0x00400030]
[0x00400034]
[0x00400038]
[0x0040003c]
[0x00400040]

0x22100002
0x00104020
0x01084820
0x01295020
0x014a5820
0x016b6020
0x018c6820
0x01ad7020
0x01ce7820

addi $16, $16, 2

add $8, $0, $16
add $9, $8, $8
add $10, $9, $9
add $11, $10, $10
add $12, $11, $11
add $13, $12, $12
add $14, $13, $13
add $15, $14, $14

; 4: addi $s0,$s0,2
; 5: add $t0,$zero,$s0
; 6: add $t1,$t0,$t0
; 7: add $t2,$t1,$t1
; 8: add $t3,$t2,$t2
; 9: add $t4,$t3,$t3
; 10: add $t5,$t4,$t4
; 11: add $t6,$t5,$t5
; 12: add $t7,$t6,$t6

Cambiando el valor inicial de $s0 por 4. Se debe conseguir una secuencia del
tipo:
$t0 = 4 = 0x4
$t1 = 8 = 0x8.
$t2 = 16 = 0x10.
$t3 = 32 = 0x20.
$t4 = 64 = 0x40.
$t5 = 128 = 0x80.
$t6 = 256 = 0x100.
$t7 = 512 = 0x200.

Lo que se puede observar en los registros respectivos de la simulacin en el programa

assembler es :
R0
R1
R2
R3
R4
R5
R6
R7

(r0) = 0x00000000
(at) = 0x00000000
(v0) = 0x0000000a
(v1) = 0x00000000
(a0) = 0x00000000
(a1) = 0x7ffff000
(a2) = 0x7ffff004
(a3) = 0x00000000

General Registers
R8 (t0) = 0x00000004 R16 (s0) = 0x00000004
R9 (t1) = 0x00000008 R17 (s1) = 0x00000000
R10 (t2) = 0x00000010 R18 (s2) = 0x00000000
R11 (t3) = 0x00000020 R19 (s3) = 0x00000000
R12 (t4) = 0x00000040 R20 (s4) = 0x00000000
R13 (t5) = 0x00000080 R21 (s5) = 0x00000000
R14 (t6) = 0x00000100 R22 (s6) = 0x00000000
R15 (t7) = 0x00000200 R23 (s7) = 0x00000000

R24 (t8) = 0x00000000

R25 (t9) = 0x00000000
R26 (k0) = 0x00000000
R27 (k1) = 0x00000000
R28 (gp) = 0x00000000
R29 (sp) = 0x7fffeffc
R30 (s8) = 0x00000000
R31 (ra) = 0x0040001c

Conclusin:
Ocupando la idea de sumar el mismo archivo para generar el valor que tiene el registro
siguiente se ha logrado lo pedido en la tarea. Los dos ejemplos mostrados en la simulacin
muestran que el programa es efectivo.
Solucin 2.
El programa en MIPS para el item a) es el siguiente:
.data
.text
.globl main
main:
add $t5,$t1,$t2
sub $t5,$t5,$t3
sub $t0,$t5,$t4
Tras la simulacin, los resultados fueron:
Registers
R8 (t0) = 0x00000001
R9 (t1) = 0x00000005
R10 (t2) = 0x00000007
R11 (t3) = 0x00000005

R12 (t4) = 0x00000006

R5 (a1) = 0x7ffff000
R6 (a2) = 0x7ffff004

R13 (t5) = 0x00000007 R21

Los resultados obtenidos son los esperados. Es impotante sealar que las variables a,b,c,d,e fueron
asociadas a los registros t0, t1, t2, t3, t4 respectivamente. Luego se inicializaron los registros con valores
arbitrarios y se comprob que se estuviera realizando la operacin aritmtica pedida.
En caso que se ingresara una inicializacin de variables tal que en alguna sustraccin el resultado
fuera negativo, el resultado se desbordar y dependiendo de la magnitud del desborde el valor que tomar el
registro ser grande y cercano al cero. A continuacin se anexa un ejemplo.
Registers
R8 (t0) = 0xfffffffe
R9 (t1) = 0x00000002
R10 (t2) = 0x00000003
R11 (t3) = 0x00000004
R12 (t4) = 0x00000003
R5 (a1) = 0x7ffff000 R13 (t5) = 0x00000001 R21
R6 (a2) = 0x7ffff004
El programa en MIPS para el item b) es el siguiente:
.data
.text
.globl main
main:
addi $s1,$zero,1
mulo $t0,$s0,$s1
addi $s1,$zero,2
mulo $t1,$s0,$s1
addi $s1,$zero,4
mulo $t2,$s0,$s1
addi $s1,$zero,8
mulo $t3,$s0,$s1
addi $s1,$zero,16
mulo $t4,$s0,$s1
addi $s1,$zero,32
mulo $t5,$s0,$s1
addi $s1,$zero,64
mulo $t6,$s0,$s1
addi $s1,$zero,128
mulo $t7,$s0,$s1
Se realizaron tres simulaciones, correspondientes a tres valores del registro s0 distintos. Los
resultados para las simulaciones fueron:
Simulacin 1: $s0 = 1

R8 (t0) = 0x00000001
R16 (s0) = 0x00000001
R9 (t1) = 0x00000002
R17 (s1) = 0x00000080
R10 (t2) = 0x00000004
R11 (t3) = 0x00000008
R12 (t4) = 0x00000010
R5 (a1) = 0x7ffff000 R13 (t5) = 0x00000020

R6 (a2) = 0x7ffff004 R14 (t6) = 0x00000040

R15 (t7) = 0x00000080

Simulacin 2: $s0 = 2

R8 (t0) = 0x00000002 R16 (s0) = 0x00000002

R9 (t1) = 0x00000004 R17 (s1) = 0x00000080
R10 (t2) = 0x00000008
R11 (t3) = 0x00000010
R12 (t4) = 0x00000020
R5 (a1) = 0x7ffff000 R13 (t5) = 0x00000040
R6 (a2) = 0x7ffff004 R14 (t6) = 0x00000080
R15 (t7) = 0x00000100
Simulacin 3: $s0 = 6
R8 (t0) = 0x00000006 R16 (s0) = 0x00000006
R9 (t1) = 0x0000000c R17 (s1) = 0x00000080
R10 (t2) = 0x00000018
R11 (t3) = 0x00000030
R12 (t4) = 0x00000060
R5 (a1) = 0x7ffff000 R13 (t5) = 0x000000c0
R6 (a2) = 0x7ffff004 R14 (t6) = 0x00000180
R15 (t7) = 0x00000300

Observaciones
-

A pesar que los resultados obtenidos en b) fueron satisfactorios, queda la sensacin que pudiera existir un
mtodo ms eficiente de programarlo. Sin embargo, el repertorio de instrucciones utilizado es el conocido
hasta la fecha.
La inicializacin de valores de los registros se realiz mediante la instruccin Set Values de la ventana
Simulator del PCSpim