Examen: Parcial 1:2026_10_28:Datos - myTeachingURJC/Arq-computadores-01 GitHub Wiki

Examen Parcial 2: Propuesta 01
- Tiempo: 50 minutos
- Tipo de examen: Presencial. Realizado a través de Aula Virtual. Acceso a la wiki (Internet)
- Temario: S5, S6, S7 y S8
Contenido
Enunciado
El examen se ha realizado a través de Aula virtual. Tiene dos partes: Test y un problema
Test (5 ptos)
- Realizado a través de Aula virtual
- 10 preguntas tipo test
- Las respuestas incorrectas restan un 33% del valor de la pregunta
- Solución disponible en Aula virtual
Problema (5 ptos): Ordenación, alineamiento y direccionamiento
Tenemos un computador de 32 bits con las siguientes características:
- Registros: 16 registros de propósito general (
x0-x15) de 32 bits. - Ordenación (endianness): Big-endian.
- Direccionamiento: Directo (la dirección del dato aparece en la propia instrucción).
- Anchura de memoria: 16 bits.
- Restricciones: Sólo permite el acceso a datos alineados.
- Cargas: Las cargas de byte y media palabra rellenan con ceros los bits más significativos del registro (no hay extensión de signo).
Instrucciones disponibles
lb rd, dir: Leer un byte de la direccióndiry guardarlo enrd.lh rd, dir: Leer una media palabra de la direccióndiry guardarla enrd.lw rd, dir: Leer una palabra de la direccióndiry guardarla enrd.sb rs2, dir: Almacenar en memoria, a partir de la direccióndir, el byte menos significativo del registrors2.sh rs2, dir: Almacenar en memoria, a partir de la direccióndir, la media palabra menos significativa del registrors2.sw rs2, dir: Almacenar en memoria, a partir de la direccióndir, la palabra menos significativa del registrors2.
Estado de la memoria (volcado hexadecimal)
Este es el contenido de la memoria a partir de la dirección 0x2A40. Los valores están en HEXADECIMAL. El resto de la memoria está inicializada a 0.
| Dirección | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0x2A40 | 95 |
D9 |
32 |
E9 |
F8 |
8B |
ED |
5C |
78 |
0D |
AA |
81 |
37 |
9B |
39 |
EB |
| 0x2A50 | 4A |
7D |
B2 |
C9 |
37 |
55 |
F9 |
71 |
13 |
42 |
32 |
2A |
17 |
72 |
C6 |
8A |
| 0x2A60 | 00 |
00 |
00 |
00 |
00 |
00 |
00 |
00 |
00 |
00 |
00 |
00 |
00 |
00 |
00 |
00 |
Código a ejecutar
#-- BLOQUE I (Cargas)
lb x3, 0x2A45
lh x4, 0x2A4C
lw x5, 0x2A48
lh x6, 0x2A47
lw x7, 0x2A52
ld x8, 0x2A50
lw x9, 0x2A54
lb x17, 0x2A41
#-- BLOQUE II (Almacenamiento)
sw x5, 0x2A60
sh x4, 0x2A62
sb x3, 0x2A67
sw x9, 0x2A6C
sh x9, 0x2A69
sw x4, 0x2A6A
sb x5, 0x2A6A
Inicialmente todos los registros están a 0. El bloque II se ejecuta a continuación del bloque I, por lo que utiliza los valores cargados en los registros.
a) Indica qué instrucciones darían error al ejecutarse en este procesador y por qué.
b) Considerando sólo las instrucciones que no dan error, indica el valor (en hexadecimal) de los registros x3, x4, x5, x6, x7, x8, x9 al terminar de ejecutarse el bloque I.
c) Escribe el contenido de los 16 bytes de memoria situados a partir de la dirección 0x2A60 al terminar de ejecutarse el bloque II (sólo las instrucciones que no dan error).
d) Indica el número de accesos a memoria que emplea cada instrucción de carga y almacenamiento válida (no tengas en cuenta el acceso para leer la propia instrucción).
Solución al problema
Con direccionamiento directo la dirección del dato aparece directamente en la instrucción.
Como la anchura de memoria es de 16 bits, en cada acceso se transfieren 2 bytes alineados a una dirección múltiplo de 2. Un dato necesita tantos accesos como palabras de memoria distintas ocupe.
a)
| Instrucción | Tipo de error | Justificación |
|---|---|---|
lh x6, 0x2A47 |
Fallo de alineamiento | Una media palabra (2 bytes) requiere una dirección múltiplo de 2. 0x2A47 no lo es. |
lw x7, 0x2A52 |
Fallo de alineamiento | Una palabra (4 bytes) requiere una dirección múltiplo de 4. 0x2A52 no lo es. |
ld x8, 0x2A50 |
Instrucción ilegal | ld maneja datos de 64 bits y no pertenece al repertorio de un procesador de 32 bits. |
lb x17, 0x2A41 |
Registro inválido | El procesador sólo tiene los registros x0-x15. El registro x17 no existe. |
sh x9, 0x2A69 |
Fallo de alineamiento | Una media palabra (2 bytes) requiere una dirección múltiplo de 2. 0x2A69 no lo es. |
sw x4, 0x2A6A |
Fallo de alineamiento | Una palabra (4 bytes) requiere una dirección múltiplo de 4. 0x2A6A no lo es. |
Estas instrucciones no se ejecutan: no modifican ni registros ni memoria y no se tienen en cuenta en el resto de apartados.
b)
Al ser big-endian, el byte situado en la dirección más baja es el más significativo: el valor se lee en el mismo orden en que aparecen los bytes en memoria. Las cargas rellenan con ceros la parte alta del registro.
lb x3, 0x2A45:- Lee el byte de la dirección
0x2A45:8B. - Resultado:
x3 = 0x8B
- Lee el byte de la dirección
lh x4, 0x2A4C:- Lee 2 bytes desde
0x2A4C(dirección alineada):37,9B. - Big-endian forma:
0x379B. - Resultado:
x4 = 0x379B
- Lee 2 bytes desde
lw x5, 0x2A48:- Lee 4 bytes desde
0x2A48(dirección alineada):78,0D,AA,81. - Big-endian forma:
0x780DAA81. - Resultado:
x5 = 0x780DAA81
- Lee 4 bytes desde
lw x9, 0x2A54:- Lee 4 bytes desde
0x2A54(dirección alineada):37,55,F9,71. - Big-endian forma:
0x3755F971. - Resultado:
x9 = 0x3755F971
- Lee 4 bytes desde
Resumen:
| Registro | Valor final |
|---|---|
x3 |
0x8B |
x4 |
0x379B |
x5 |
0x780DAA81 |
x6 |
0x0 (no se modifica: su instrucción da error) |
x7 |
0x0 (no se modifica: su instrucción da error) |
x8 |
0x0 (no se modifica: su instrucción da error) |
x9 |
0x3755F971 |
c)
Ejecutamos las instrucciones en orden. En big-endian el byte más significativo del dato se guarda en la dirección más baja.
sw x5, 0x2A60: escribe la palabra0x780DAA81(dex5 = 0x780DAA81)0x2A60<-780x2A61<-0D0x2A62<-AA0x2A63<-81
sh x4, 0x2A62: escribe la media palabra0x379B(dex4 = 0x379B)0x2A62<-37(sobrescribe el valorAAescrito por una instrucción anterior)0x2A63<-9B(sobrescribe el valor81escrito por una instrucción anterior)
sb x3, 0x2A67: escribe el byte0x8B(dex3 = 0x8B)0x2A67<-8B
sw x9, 0x2A6C: escribe la palabra0x3755F971(dex9 = 0x3755F971)0x2A6C<-370x2A6D<-550x2A6E<-F90x2A6F<-71
sb x5, 0x2A6A: escribe el byte0x81(dex5 = 0x780DAA81)0x2A6A<-81
| Dirección | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0x2A60 | 78 |
0D |
37 |
9B |
00 |
00 |
00 |
8B |
00 |
00 |
81 |
00 |
37 |
55 |
F9 |
71 |
d)
Con una anchura de 16 bits, las palabras de memoria empiezan en direcciones múltiplo de 2. No se cuenta el acceso para leer la propia instrucción (fetch). Las instrucciones li y addi no acceden a memoria.
| Instrucción | Tipo | Dirección | Tamaño | Accesos | Explicación |
|---|---|---|---|---|---|
lb x3, 0x2A45 |
Load | 0x2A45 |
8 bits | 1 | Un byte siempre cae dentro de una única palabra de memoria. |
lh x4, 0x2A4C |
Load | 0x2A4C |
16 bits | 1 | Los 2 bytes están dentro de la palabra de memoria 0x2A4C. |
lw x5, 0x2A48 |
Load | 0x2A48 |
32 bits | 2 | 32 bits requieren 2 transferencias de 16 bits. |
lw x9, 0x2A54 |
Load | 0x2A54 |
32 bits | 2 | 32 bits requieren 2 transferencias de 16 bits. |
sw x5, 0x2A60 |
Store | 0x2A60 |
32 bits | 2 | 32 bits requieren 2 transferencias de 16 bits. |
sh x4, 0x2A62 |
Store | 0x2A62 |
16 bits | 1 | Los 2 bytes están dentro de la palabra de memoria 0x2A62. |
sb x3, 0x2A67 |
Store | 0x2A67 |
8 bits | 1 | Un byte siempre cae dentro de una única palabra de memoria. |
sw x9, 0x2A6C |
Store | 0x2A6C |
32 bits | 2 | 32 bits requieren 2 transferencias de 16 bits. |
sb x5, 0x2A6A |
Store | 0x2A6A |
8 bits | 1 | Un byte siempre cae dentro de una única palabra de memoria. |
En total se realizan 13 accesos a memoria para datos.
Autores

Licencia
