Universidad Nacional de San Agustín de

Arequipa
Escuela profesional de ingeniería Electrónica
ARQUITECTURA DE COMPUTADORAS
TURNO: Miercoles 10:40 a 12:20 horas

Laboratorio 4
Ccahuachia Zapacayo, Wilmer

Docente
Ing. [Link] BETCY VALCÁRCEL YUCRA

19 de octubre del 2024

Laboratorio ARQUITECTURA DE COMPUTADORAS

Laboratorio 4

Ejercicio 1

1. Escribe un programa en ensamblador (init.s) para inicializar los registros x5, x6, x7
y x8 con los valores 5, 6, 7 y 8 respectivamente. Utiliza li. Además, estos valores se
deben transferir a los registros x15, x16, x17 y x18 respectivamente: x15 = x5, x16
= x6, x17 = x7 y x18 = x8. Usa mv. Por último, el programa termina

1 # Inicializar registros x5, x6, x7 y x8

2 li x5, 5 # x5 = 5
3 li x6, 6 # x6 = 6
4 li x7, 7 # x7 = 7
5 li x8, 8 # x8 = 8
6

7 # Transferir valores a x15, x16, x17, y x18

8 mv x15, x5 # x15 = x5
9 mv x16, x6 # x16 = x6
10 mv x17, x7 # x17 = x7
11 mv x18, x8 # x18 = x8
12

13 nop

1
Laboratorio ARQUITECTURA DE COMPUTADORAS

2. ¿Cuántas instrucciones tiene el programa?

9 instrucciones

3. ¿Cuántos bytes ocupa el programa?

4 X # Numero de instrucciones 4 x 9 = 36 bytes

4. Obtén el código máquina exportando a un fichero en formato hexadecimal ([Link])

2
 Laboratorio ARQUITECTURA DE COMPUTADORAS

Ejercicio 2 Analiza el siguiente programa

1 .data
2

3 a:
4 b:
5 .word 1,2,3,4
6

7 c:
8 .word 10
9 .word 20
10 d:
11 .word 30
12 e:
13

14 .text
15 li a7, 10
16 ecall
17

1. ¿Cuántas palabras hay almacenadas en el segmento de datos?

7 palabras

2. ¿Cuántos bytes ocupa el segmento de datos?

28 bytes

3. ¿Cuántos bytes ocupa el programa?

8 bytes

4. Escribe en una tabla las direcciones de las etiquetas:

Etiqueta Direccion
a 0x10010000
b 0x10010000
c 0x10010010
d 0x10010018
e 0x1001001c

5. ¿Qué palabra hay almacenada en la dirección 0x10010014?

2

6. Rellena esta tabla, indicando qué bytes están almacenados en cada dirección

Dirección (alineada) Byte

0x0040000 15
0x0040004 16

3
Laboratorio ARQUITECTURA DE COMPUTADORAS

4
 Laboratorio ARQUITECTURA DE COMPUTADORAS

Ejercicio 3 Escribe un programa (variables4.s) que tenga un segmento de datos

con 4 variables: v1, v2, v3 y v4, inicializadas con los valores 0x12345678, 0x11223344,
0xCACABACA, 0x00FABADA respectivamente. En el segmento de código sólo deben
estar las instrucciones para terminar.

1 .data
2 v1: .word 0x12345678
3 v2: .word 0x11223344
4 v3: .word 0xCACABACA
5 v4: .word 0x00FABADA
6

7 .text
8 li a7, 10
9 ecall
10

5
Laboratorio ARQUITECTURA DE COMPUTADORAS

1. Ensambla el programa y comprueba que las palabras se encuentran en el segmento

de datos. Se observa que las palabras si se encuentran en el segmento de
datos.

2. Exporta el segmento de datos a un fichero hexadecimal ([Link]) y comprue-

ba que estén los valores de las 4 variables

3. Exporta el segmento de datos a un fichero binario ([Link]) y examina los

bytes con el comando hd (o cualquier visor hexadecimal que tengas instalado en
tu sistema). ¿Qué byte está almacenado en la quinta posición? ¿A qué dirección
corresponde? 00000000

6
Laboratorio ARQUITECTURA DE COMPUTADORAS

Ejercicio 4

1. Escribe un programa en ensamblador (vardir.s) que defina 4 variables: a,b,c y d

inicializadas a 0. Debe cargar en los registros x5,x6,x7 y x8 las direcciones de cada
una de ellas usando 4 pseudoinstrucciones la

2 .text
3

4 #--- Dar un valor a las variables (puede ser cualquiera)

5 #-- para comprobar que el cálculo funciona
6 addi x3, x0, 30
7 addi x4, x0, 2
8 addi x5, x0, 4
9 addi x6, x0, 6
10 addi x7, x0, 8
11 addi x8, x0, 10
12

13 #----- Codigo para calcular la expresion genérica

14 #---- x10 = (x5 + x6) - x7 + x8 + 50
15

16 #-- Calculamos f = (a + b +c)

17 add x10, x4, x5
18 add x10,x10,x6
19 #-- Calculamos (-a + d). Lo almacenamos por ejemplo en x9
20 sub x9, x7, x4 # x9 = d - a
21 #-- Calculamos (e + 3)
22 addi x8, x8, 3
23 #-- Calculamos (d-a)+(e+3)
24 add x9, x9, x8
25 #--calculamos [(d-a)+(e+3)-30]
26 sub x9,x9,x3
27 #-- Calculamos la expresion final: (a+b+c)-[(d-a)+(e+3)-30]
28 sub x10, x10, x9
29

30

31 #-- Terminar
32 li a7, 10
33 ecall

7
Laboratorio ARQUITECTURA DE COMPUTADORAS

2. Ensambla el programa. Abre la tabla de símbolos y comprueba que en los registros

x5-x8 se han cargado las direcciones de las variables a-d respectivamente

3. ¿Cuántos bytes ocupa el programa?

40 bytes

8
Laboratorio ARQUITECTURA DE COMPUTADORAS

Ejercicio 5
1. Modifica el programa anterior (llámalo vardir2.s) para que cargue los valores de las
variables a,b,c y d en los registros x10, x11, x12 y x13. En el segmento de datos las
variables deben estar inicializadas a 1,2,3 y 4 respectivamente. Ensambla el progra-
ma y comprueba que los registros x10-x13 tiene los valores 1,2,3 y 4 respectivamente

2. ¿Cuántos bytes ocupa el programa?

56 bytes
. data
a: . word 1
b: . word 2
c: . word 3
d: . word 4
. text
. g l o b l _start
_start :
l a x5 , a
l a x6 , b
l a x7 , c
l a x8 , d
lw x10 , 0 ( x5 ) # Cargar el valor de 'a ' en x10
lw x11 , 0 ( x6 ) # Cargar el valor de 'b ' en x11
lw x12 , 0 ( x7 ) # Cargar el valor de 'c ' en x12
lw x13 , 0 ( x8 ) # Cargar el valor de 'd ' en x13
l i a7 , 10
ecall

9
Laboratorio ARQUITECTURA DE COMPUTADORAS

Ejercicio 6

1. Haz una nueva versión del programa anterior (vardir3.s) que haga lo mismo PERO
usando sólo el registro x5 con la dirección de la variable a. Este registro NO se
puede modificar, siempre debe contener la dirección de a, y es el único que se puede
usar para acceder al resto de variables. En los registros x10-x13 se deben cargar
los valores de las variables a,b,c y d (que valen 1,2,3 y 4, igual que en la versión
anterior)

2. ¿Cuántos bytes ocupa este nuevo programa?

32 bytes

3. ¿Cuál de los dos métodos usarías para acceder a las variables si queremos que el
programa ocupe el menor espacio posible en la memoria?
El programa vardir3.s

10
Laboratorio ARQUITECTURA DE COMPUTADORAS

Ejercicio 7

1. Escribe un programa (expresion.s) que calcule la siguiente expresión: f = (a + b +

c) - (d - 3). Implementa la expresión tal cual, sin hacer simplificaciones y respetando
la prioridad de los paréntesis
Las variables a,b,c,d y f están en la memoria, inicializadas con los valores 5, 2, 30,
5 y 0 respectivamente. El resultado final se debe depositar en la variable f

1 la x7, c
2 la x8, d
3 la x9, f
4

5 lw x10, 0(x5) # Cargar 'a' en x10

6 lw x11, 0(x6) # Cargar 'b' en x11
7 lw x12, 0(x7) # Cargar 'c' en x12
8 lw x13, 0(x8) # Cargar 'd' en x13
9

10 # Calculamos (a + b + c)
11 add x14, x10, x11 # x14 = a + b
12 add x14, x14, x12 # x14 = (a + b) + c
13

14 # Calcular (d - 3)
15 li x15, 3 # Cargar el valor 3 en x15
16 sub x16, x13, x15 # x16 = d - 3
17

18 # Calculamos f = (a + b + c) - (d - 3)
19 sub x17, x14, x16 # x17 = (a + b + c) - (d - 3)
20

21 sw x17, 0(x9) # Guardar el valor de x17 en la dirección de 'f'

22

23 li a7, 10
24 ecall
25

2. Ensámblalo y comprueba que el valor calculado en la variable f es correcto.

0x10010010

3. ¿Cuántos bytes ocupa el programa?

22x4 byte= 88 bytes

4. ¿En qué dirección de memoria está almacenada la variable f?

X9

11
Laboratorio ARQUITECTURA DE COMPUTADORAS

Ejercicio 8

1. Escribe un programa (fibonacci.s) que calcule la sucesión de Fibonacci. En las va-

riables fib0 y fib1 se deben almacenar los valores iniciales: 0 y 1 y a partir de ellos se
calculan el resto de los términos de la sucesión, que se irán almacenando en palabras
consecutivas de la memoria. El cálculo se realiza indefinidamente, usando un bucle
infinito. Para probarlo, coloca un Breakpoint y ejecuta el programa manualmente
para comprobar que en la memoria aparecen los términos de la sucesión.

1 .data
2 fib0: .word 0
3 fib1: .word 1
4 next: .word 0
5

6 .text
7 .globl _start
8 _start:
9 la x5, fib0 # Cargar la dirección de fib0 en x5
10 la x6, fib1 # Cargar la dirección de fib1 en x6
11 la x7, next # Cargar la dirección donde se almacenarán los próximos val
12

13 # Inicializar registros para Fibonacci

14 lw x10, 0(x5) # Cargar fib0 en x10
15 lw x11, 0(x6) # Cargar fib1 en x11
16

17 # Bucle infinito
18 fib_loop:
19 # Almacenar el valor actual de Fibonacci en la siguiente posición de la memo
20 sw x10, 0(x7) # Almacenar el valor de fib0 en la dirección de next

12
Laboratorio ARQUITECTURA DE COMPUTADORAS

21 addi x7, x7, 4 # Incrementar la dirección para la próxima palabra

22

23 # Calcular el siguiente término de Fibonacci

24 add x12, x10, x11 # x12 = fib0 + fib1
25

26 # Actualizar los valores de fib0 y fib1

27 mv x10, x11 # fib0 = fib1
28 mv x11, x12 # fib1 = fib0 + fib1
29

30 j fib_loop
31 .data
32 fib0: .word 0
33 fib1: .word 1
34 next: .word 0
35

36 .text
37 .globl _start
38 _start:
39 la x5, fib0 # Cargar la dirección de fib0 en x5
40 la x6, fib1 # Cargar la dirección de fib1 en x6
41 la x7, next # Cargar la dirección donde se almacenarán los próximos val
42

43 # Inicializar registros para Fibonacci

44 lw x10, 0(x5) # Cargar fib0 en x10
45 lw x11, 0(x6) # Cargar fib1 en x11
46

47 # Bucle infinito
48 fib_loop:
49 # Almacenar el valor actual de Fibonacci en la siguiente posición de la memo
50 sw x10, 0(x7) # Almacenar el valor de fib0 en la dirección de next
51 addi x7, x7, 4 # Incrementar la dirección para la próxima palabra
52

53 # Calcular el siguiente término de Fibonacci

54 add x12, x10, x11 # x12 = fib0 + fib1
55

56 # Actualizar los valores de fib0 y fib1

57 mv x10, x11 # fib0 = fib1
58 mv x11, x12 # fib1 = fib0 + fib1
59

60 j fib_loop
61

62

2. Quita el breakpoint y dale a ejecutar... (deja configurada el simulador para funcionar

a la máxima velocidad). Espera unos 10 segundos. ¿Qué sucede? ¿Sabrías explicar
qué ha pasado?
Observamos que el segmento de datos la memoria se esta rellenando

13
Laboratorio ARQUITECTURA DE COMPUTADORAS

Ejercicio 9
Utiliza el monitor de memoria con el programa anterior de Fibonacci. Pon un break-
point y comprueba si se accede a todas las posiciones de memoria secuencialmente

14
Laboratorio ARQUITECTURA DE COMPUTADORAS

Ejercicio 10 En un sistema con RISC-V que está funcionando en la estación es-

pacial internacional se ha detectado la llegada de unos rayos gamas que podrían haber
destruido ciertas direcciones de memoria. Necesitamos crear un programa que acceda a
esas posiciones, y sólo a esas, escribiendo el valor 0xAA5555AA en ellas Las direcciones
a comprobar son 4, correspondientes a las palabras 1, 4,5 y 8 del segmento de datos. Al
ejecutar el programa, se debe generar el siguiente patrón en el Monitor de memoria.

Solucion

15
Laboratorio ARQUITECTURA DE COMPUTADORAS

Ejercicio 11
Escribe un programa que genere este patrón de acceso a memoria en el visualizar de
memoria

Solucion

16
Laboratorio ARQUITECTURA DE COMPUTADORAS

17
Laboratorio ARQUITECTURA DE COMPUTADORAS

CONCLUSIONES

El uso de un programa en ensamblador permite controlar exactamente qué posicio-

nes de memoria son modificadas. En este caso, se pudo generar un patrón específico
en el monitor de memoria, lo que demuestra que, se pueden realizar manipulaciones
de la memoria.

Este tipo de programas permite obtimizar optimización el codigo en el esamblador.

Se logro crear programas combinando las intrucciones como para realizar suma,
resta y otros.

El uso de un bucle infinito es importante para pausar el programa y permitir la

observación de los efectos en el monitor de memoria,

18