Examen: Parcial 1:2026_10_08:TELECO - myTeachingURJC/Arq-computadores-01 GitHub Wiki

Examen Parcial 1: 2026-10-08. Teleco

  • Tiempo: 50 minutos
  • Tipo de examen: Presencial. Realizado a través de Aula Virtual. Acceso a la wiki (Internet)
  • Temario: S1, S5, S6 y S7

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 64-bits con las siguientes características:

  • Registros: 32 registros de propósito general (x0-x31).
  • Endianness: Little-endian.
  • Direccionamiento: Indirecto.
  • Anchura de memoria: 32 bits.
  • Restricciones: Puede acceder tanto a datos alineados como no alineados.

Instrucciones Disponibles

  • li rd, valor: Carga del valor inmediato en el registro rd.
  • addi rd, rs, valor: Suma el valor del registro rs más valor y lo almacena en el registro rd.
  • lb rd, (rs1): Leer un byte de memoria y guardarlo en rd.
  • lh rd, (rs1): Leer una media palabra de memoria y guardarla en rd.
  • lw rd, (rs1): Leer una palabra de memoria y guardarla en rd.
  • ld rd, (rs1): Leer una doble palabra de memoria y guardarla en rd.
  • sb rs1, (rs2): Almacenar en memoria el byte que hay en rs1.
  • sh rs1, (rs2): Almacenar en memoria la media palabra que hay en rs1.
  • sw rs1, (rs2): Almacenar en memoria la palabra que hay en rs1.
  • sd rs1, (rs2): Almacenar en memoria la doble palabra que hay en rs1.

Estado de la Memoria (Volcado Hexadecimal)

Este es un volcado de la memoria, correspondiente a las direcciones que comienzan en 0xFF010 y 0xFF020. Los valores están en HEXADECIMAL.

Dirección 0 1 2 3 4 5 6 7 8 9 A B C D E F
0xFF010 AA BB CC DD 01 02 03 04 A4 A3 A2 A1 A0 1F 1E 1A
0xFF020 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00

Se pide:

a) Indicar el valor de los registros del x1 al x5 cuando se ejecutan estas instrucciones (secuencialmente), así como el número de accesos a memoria que emplea cada instrucción de load para leer los datos:

li x1, 0xFF010
lb x2, (x1)
addi x1, x1, 2
lh x3, (x1)
lw x4, (x1)
addi x1, x1, 6
ld x5, (x1)

b) Suponiendo que inicialmente los registros del x1 al x5 contienen los siguientes valores: x1=0, x2=0x22, x3=0x2023, x4=0x1A2B3C4D, x5=0x44332211DDCCBBAA

Escribe el contenido de los 16 bytes de memoria situados desde la dirección 0xFF020 en adelante al terminar de ejecutarse las siguientes instrucciones:

li x1, 0xFF020
sd x5, (x1)
li x1, 0xFF022
sh x3, (x1)
addi x1, x1, 6
sw x4, (x1)
sb x2, (x1)

c) Calcula el número de accesos a memoria que emplea cada instrucción de load para leer los datos (no incluyas los accesos para leer la propia instrucción)

Solución al problema

Con direccionamiento indirecto la dirección del dato no aparece en la instrucción: está almacenada en el registro que va entre paréntesis. Por eso hay que ir siguiendo el valor de x1, que se modifica con li y addi.

Como la anchura de memoria es de 32 bits, en cada acceso se transfiere una palabra completa de 4 bytes, alineada a una dirección múltiplo de 4. Las palabras de memoria del volcado son:

Palabra de memoria Bytes que contiene Contenido (por orden de dirección)
0xFF010 0xFF010 - 0xFF013 AA BB CC DD
0xFF014 0xFF014 - 0xFF017 01 02 03 04
0xFF018 0xFF018 - 0xFF01B A4 A3 A2 A1
0xFF01C 0xFF01C - 0xFF01F A0 1F 1E 1A

Un dato necesita tantos accesos como palabras de memoria distintas ocupe. Un dato no alineado puede quedar repartido entre dos palabras y necesitar un acceso más.

a)

Ejecutamos las instrucciones en orden. Al ser little-endian, el byte situado en la dirección más baja es el menos significativo: para obtener el valor hay que leer los bytes de la dirección más alta a la más baja.

  1. li x1, 0xFF010:

    • No accede a memoria. Carga el valor inmediato en x1.
    • Resultado: x1 = 0xFF010

  2. lb x2, (x1):

    • Lee 1 byte en la dirección 0xFF010: 0xAA.
    • Resultado: x2 = 0xAA
    • Accesos: 1 (el byte está dentro de la palabra 0xFF010).

  3. addi x1, x1, 2:

    • No accede a memoria. 0xFF010 + 2 = 0xFF012.
    • Resultado: x1 = 0xFF012

  4. lh x3, (x1):

    • Lee 2 bytes en 0xFF012 y 0xFF013. Valores: 0xCC y 0xDD.
    • Little-endian forma: 0xDDCC.
    • Resultado: x3 = 0xDDCC
    • Accesos: 1 (los dos bytes están dentro de la palabra 0xFF010).

  5. lw x4, (x1):

    • Lee 4 bytes desde 0xFF012 (dirección no alineada: no es múltiplo de 4).
    • Valores consecutivos: 0xCC, 0xDD, 0x01, 0x02.
    • Little-endian forma: 0x0201DDCC.
    • Resultado: x4 = 0x0201DDCC
    • Accesos: 2. Los bytes 0xFF012-0xFF013 están en la palabra 0xFF010 y los bytes 0xFF014-0xFF015 en la palabra 0xFF014.

  6. addi x1, x1, 6:

    • No accede a memoria. 0xFF012 + 6 = 0xFF018.
    • Resultado: x1 = 0xFF018

  7. ld x5, (x1):

    • Lee 8 bytes desde 0xFF018 (alineado).
    • Valores consecutivos: 0xA4, 0xA3, 0xA2, 0xA1, 0xA0, 0x1F, 0x1E, 0x1A.
    • Little-endian forma: 0x1A1E1FA0A1A2A3A4.
    • Resultado: x5 = 0x1A1E1FA0A1A2A3A4
    • Accesos: 2. 64 bits requieren dos transferencias de 32 bits (palabras 0xFF018 y 0xFF01C).

Resumen:

Registro Valor final Instrucción de load Accesos a memoria
x1 0xFF018 — —
x2 0xAA lb x2, (x1) 1
x3 0xDDCC lh x3, (x1) 1
x4 0x0201DDCC lw x4, (x1) 2
x5 0x1A1E1FA0A1A2A3A4 ld x5, (x1) 2

b)

Ejecutamos las instrucciones en orden secuencial. Al ser little-endian, el byte menos significativo del registro se guarda en la dirección más baja:

  1. li x1, 0xFF020: x1 = 0xFF020.
  2. sd x5, (x1): Escribe la doble palabra de x5 (0x44332211DDCCBBAA) ocupando 8 bytes desde 0xFF020.
    • 0xFF020 <- 0xAA
    • 0xFF021 <- 0xBB
    • 0xFF022 <- 0xCC
    • 0xFF023 <- 0xDD
    • 0xFF024 <- 0x11
    • 0xFF025 <- 0x22
    • 0xFF026 <- 0x33
    • 0xFF027 <- 0x44
  3. li x1, 0xFF022: x1 = 0xFF022.
  4. sh x3, (x1): Escribe la media palabra de x3 (0x2023) ocupando 2 bytes desde 0xFF022.
    • 0xFF022 <- 0x23 (Nota: sobrescribe el valor 0xCC puesto por sd).
    • 0xFF023 <- 0x20 (Nota: sobrescribe el valor 0xDD puesto por sd).
  5. addi x1, x1, 6: x1 = 0xFF022 + 6 = 0xFF028.
  6. sw x4, (x1): Escribe la palabra de x4 (0x1A2B3C4D) ocupando 4 bytes desde 0xFF028.
    • 0xFF028 <- 0x4D
    • 0xFF029 <- 0x3C
    • 0xFF02A <- 0x2B
    • 0xFF02B <- 0x1A
  7. sb x2, (x1): Escribe el byte menos significativo de x2 (0x22) en 0xFF028.
    • 0xFF028 <- 0x22 (Nota: sobrescribe el valor 0x4D puesto por sw).
Dirección 0 1 2 3 4 5 6 7 8 9 A B C D E F
0xFF020 AA BB 23 20 11 22 33 44 22 3C 2B 1A 00 00 00 00

c)

Aunque el enunciado dice "load", se refiere a las instrucciones del apartado b), que son de almacenamiento (store). Considerando una anchura de memoria de 32 bits, cada acceso al bus transfiere 4 bytes alineados. (No se contabiliza el acceso para leer la propia instrucción, "Instruction Fetch").

Instrucción Dirección Tamaño dato Accesos Datos Explicación
li x1, 0xFF020 — — 0 No accede a memoria: el valor es un inmediato.
sd x5, (x1) 0xFF020 64 bits 2 64 bits requieren dos ciclos de escritura de 32 bits (palabras 0xFF020 y 0xFF024).
li x1, 0xFF022 — — 0 No accede a memoria: el valor es un inmediato.
sh x3, (x1) 0xFF022 16 bits 1 Los bytes 0xFF022-0xFF023 están dentro de la misma palabra (0xFF020).
addi x1, x1, 6 — — 0 Operación entre registro e inmediato. No accede a memoria.
sw x4, (x1) 0xFF028 32 bits 1 Dirección alineada: 32 bits ocupan exactamente una transferencia completa del bus.
sb x2, (x1) 0xFF028 8 bits 1 Se realiza un ciclo de escritura (o lectura-modificación-escritura).

En total, el bloque del apartado b) realiza 5 accesos a memoria para escribir los datos.

Autores

Licencia

Enlaces