Examen: 2025_06_17:GISAM:TELECO - myTeachingURJC/2019-20-LAB-AO GitHub Wiki

Examen convocatoria extraordinaria: 2025-06-17. GISAM. TELECO

  • Tiempo: Una hora y media
  • Descripción: Examen final de laboratorio. Grado de ISAM y TELECO
  • Fecha: 2025/Junio/17
  • Comentarios:
    • Acceso a Internet permitido
    • Entrega por Aula Virtual

Contenido

Enunciado

El examen se ha realizado a través de Aula virtual. Consta de dos programas

  • Ficheros a entregar:
    • Del ejercicio 1:
      • dump4.s
      • main1.s
    • Del ejercicio 2:
      • view_text.s

Bájate el fichero ZIP adjunto, con los ficheros plantilla para hacer el examen

Ejercicio 1 (6 ptos)

Implementar la función dump4(addr) en ensamblador de un RV32I. Esta función realiza un volcado de 4 palabras de memoria a partir de la dirección addr, pasada como parámetro. La operación de volcado consiste en imprimir en la consola las 4 palabras que hay a partir de la dirección addr, en formato hexadecimal. Para que en un futuro este programa sea ampliable, la impresión de estas 4 palabras se debe hacer mediante un bucle. Para imprimir un número en hexadecimal usa la llamada al sistema oportuna

La función tiene un único argumento de entrada addr, que es la dirección de la primera palabra a volcar. No tiene ningún argumento de salida

Para probar la función utilizamos un programa principal que define en el segmento de datos las siguientes 4 palabras de pruebas y llama a la función dump4 para imprimirlas en la consola: 0xCAFEBACA, 0xBEBECAFE, 0x01234567, 0x89ABCDEF

En este pantallazo se muestra el resultado de la ejecución del programa principal. Asegúrate que tu programa principal produzca exactamente esta misma salida

Todas las constantes necesarias para acceder a los servicios del sistema operativo deben estar definidas en el fichero "so.s" (que se proporciona en la plantilla)

Se pide:

a) (4 ptos) Implementar la función dump4(addr) en el fichero dump4.s

b) (2 ptos) Implementar el programa principal en el fichero main1.s

Ejercicio 2 (4 ptos)

Nuestro jefe de proyecto nos ha proporcionado dos funciones y un programa principal, situados en ficheros separados:

  • Función dump16_bytes(addr): Realiza un volcado de un bloque de 16 bytes, como caracteres. Situado en el fichero dump16_bytes.s
  • Función view_text(addr, n): Hacer un volcado de n bloques de 16 bytes. Situado en el fichero view_text.s
  • Programa principal: Define unos bytes de prueba en la memoria y llama a view_text() para visualizarlos en la consola. Situado en el fichero main2.s

Tanto el programa principal como la función dump16_bytes() funcionan correctamente. Sin embargo, la función view_text() necesita que la modifiquemos, porque la versión actual hace que el programa se meta en un bucle infinito, y por tanto nunca termina

La salida del programa principal, con la función view_text() correcta, es la mostrada en esta figura:

Tu misión como ingeniero es arreglarlo, y lograr que funcione correctamente, cumpliendo con las especificaciondes dadas

Se pide:

  • (4 ptos) Modifica la función view_text() para que el programa principal funcione correctamente. Sólo puedes añadir código en las zonas indicadas en los comentarios. No puedes modificar el CÓDIGO ORIGINAL. ¡OJO! Recuerda que si ejecutas el código tal cual está en la plantilla, provocarás un bucle infinito. Tomas las precauciones que consideres necesarias al probarlo para que no se te cuelgue el entorno de simulación (Rars)

Solución del examen

Solución al programa 1

  • Fichero dump4.s:
#------------------------------------------------------
#-- dump4(addr)  Funcion para volcar 4 palabras
#--   a partir de la direccion addr
#--   Se imprimen en HEXADECIMAL
#------------------------------------------------------

	.include "so.s"
	
	.globl dump4


#-- Implementa la funcion

	.text
dump4:	

	#Volcamos las palabras en a0 y movemos los segmentos a t0

	mv t0, a0
	
	#Cantidad de palabras
	
	li t1, 4
	
bucle:

	#-- Condicion de salida del bucle
	#-- Si el contador es 0, terminar
	beq t1, zero, fin
	

	#-- Leer palabras
	lw t2, 0(t0)
	
	# Se deberá imprimir en pantalla los datos según dump4 
	mv a0, t2
	li a7, PRINT_CHAR
	ecall
		
	
	cont:	
	#-- Apuntar a la siguiente palabra
	addi t0, t0, 4  #--- Cambiado por obijuan
	
	#-- Decrementar el contador de palabras
	addi t1, t1, -1

	#-- Repetir
	b bucle

fin:

#-- Debe existir un bucle que se repita 4 veces
#-- en cada vuelta del bucle se imprime una palabra en hexadecimal

	
	ret
  • Fichero main1.s

	#-- Incluye primero el fichero con las constantes de
	#-- acceso al sistema operativo
	
	.include "so.s"
	

	# -- Define en el segmento de datos las 4 palabras
	# -- usadas en la prueba del volcado
	
	.data


	# Datos aportados del propio enunciado
hex:		
	.word	0xCAFEBACA
	.word	0xBEBECAFE
	.word	0x01234567
	.word	0x89ABCDEF	
	.space 	4

	#-- Segmento de código: Implementa el programa principal
	
	.text

	la a0, hex
	#-- Debe llamar a la funcion dump4, pasando como argumento
	#-- la direccion a los datos
	
	jal dump4
	
	

	#-- Después debe terminar
	
fin:	

	li a7, EXIT
	ecall

Solución al programa 2

  • Fichero view_text.s:

	.include "so.s"
	
	.globl view_text
	
	.text
	
#-------------------------------------------------------
#-- view_text:
#--   Funcion para hacer un volcado de memoria (en bytes)
#--------------------------------------------------------
#- ENTRADAS:
#--   a0: Direccion de comienzo para el volcado
#--   a1: Numero de bloques (de 16 bytes) a volcar
#--------------------------------------------------------	
view_text:

# -- Añade aquí el código que consideres necesario
# -- para solucionar el problema

	#-- Es una funcion intermedia
	#-- Hay que crear la pila para guardar la direccion
	#-- de retorno
	addi sp,sp, -16
	sw ra, 12(sp)
	
	#-- Además, como en código original se usan los registros
	#-- estáticos s0 y s1, tenemos que guardarlos en la pila
	#-- para cumplir el convenio de uso de registros
	sw s0, 0(sp)
	sw s1, 4(sp)

# --------------------------------------------------
# ------ CODIGO ORIGINAL: NO LO PUEDES MODIFICAR
# --------------------------------------------------


	#-- Registro s0: Puntero a la siguiente direccion
	mv s0, a0
	
	#-- Registro s1: Contador de bloques
	mv s1, a1


bucle:
	#-- Comprobar si es el ultimo bloque
	beq s1, zero, fin
	
	#-- No es el ultimo bloque. Volcar!

	#-- Volcado de un bloque
	mv a0, s0
	mv a1, s1
	jal dump16_bytes
	
	#-- Imprimir un salto de linea
	li a0, '\n'
	li a7, PRINT_CHAR
	ecall
	
	#-- Apuntar al siguiente bloque
	addi s0, s0, 16
	
	#-- Queda un bloque menos por imprimir
	addi s1, s1, -1
	
	#-- Repetir
	b bucle
	
fin:
# --------------------------------------------------
# ------ FIN DEL CODIGO ORIGINAL
# --------------------------------------------------

# -- Añade aquí el código que consideres necesario
# -- para solucionar el problema

	#-- Recuperar registros estáticos
	lw s0, 0(sp)
	lw s1, 4(sp)
	
	#-- Recuperar direccion de retorno
	lw ra, 12(sp)
	
	#-- Restaurar la pila
	addi sp, sp, 16
	
	#-- Ahora ya se puede retornar con seguridad
	#-- El bucle infinito se produce si se ha recuperado
	#-- la direccion de retorno
	ret

Evaluación

La evaluación de cada apartado de un programa se hace en dos fases (N son los puntos de apartado)

  • Funcionalidad (N/2 puntos): Se comprueba si el programa funciona, y si cumple con las especificaciones (Nombre del fichero correcto, ensablado sin errores, sin errores en tiempo de ejecución, resultado correcto, variables definidas en sus posiciones de memoria especificadas, etc). Esto se hace mediante un script de test, que automatiza el proceso

  • Código (N/2puntos): Se inspecciona visualmente cómo está hecho el código: código limpio, claro, con comentarios, instrucciones correctas, fallos de programación, etc...

TEST automáticos

🚧 TODO 🚧

Autores

Licencia

Enlaces