E/S mapeada y no mapeada en memoria: funcionamiento y ejemplos en ARM

Entrada/Salida (E/S) Mapeada y No Mapeada en Memoria

En los sistemas computacionales, la comunicación entre la unidad central de procesamiento (CPU) y los dispositivos periféricos se realiza a través de mecanismos de Entrada/Salida (E/S). Existen dos enfoques principales para gestionar esta comunicación: la E/S mapeada en memoria y la E/S no mapeada en memoria (también conocida como E/S aislada o independiente).

E/S Mapeada en Memoria

En la E/S mapeada en memoria, se comparte el espacio de direcciones de memoria entre la memoria principal y los registros de los dispositivos de E/S. Esto significa que existe un único espacio de direcciones, y tanto las celdas de memoria como los registros de los periféricos se acceden utilizando las mismas instrucciones (por ejemplo, load y store en ensamblador).

• Ventajas:
  • Se pueden utilizar las mismas instrucciones de acceso a memoria para acceder a los registros de E/S.
  • No se requieren instrucciones especiales de E/S.
  • Se puede utilizar cualquier tipo de direccionamiento disponible para la memoria.
  • Se pueden mapear tantos registros como direcciones de memoria haya disponibles.
• Desventajas:
  • Se reduce el espacio de direcciones disponible para la memoria principal.
  • Se requiere un mecanismo para proteger los registros de E/S del acceso no autorizado por parte de programas de usuario (normalmente gestionado por el sistema operativo).

E/S No Mapeada en Memoria (E/S Aislada)

En la E/S no mapeada en memoria, existen espacios de direcciones separados para la memoria principal y los dispositivos de E/S. Esto implica que se utilizan instrucciones diferentes para acceder a la memoria y a los registros de los periféricos. A menudo, se emplean instrucciones específicas como IN y OUT para la E/S.

• Ventajas:
  • No se reduce el espacio de direcciones de la memoria principal.
  • Es más fácil controlar el acceso a los registros de E/S, ya que se requieren instrucciones específicas.
• Desventajas:
  • Se necesitan instrucciones especiales de E/S (como IN y OUT), lo que puede complicar la lógica del procesador.
  • El número de registros de E/S que se pueden direccionar suele ser limitado.
  • Se pueden requerir señales de control adicionales en el bus del sistema para distinguir entre accesos a memoria y accesos a E/S.

Registros Mapeados vs. No Mapeados

La diferencia clave radica en cómo se accede a los registros del controlador del dispositivo:

• Registros Mapeados: Los registros del controlador tienen direcciones asignadas dentro del espacio de direcciones de memoria. Se leen y escriben como si fueran ubicaciones de memoria normales.
• Registros No Mapeados: Los registros del controlador se acceden a través de instrucciones de E/S específicas (IN, OUT) y puertos de E/S.

Ejemplo de Lectura de Datos (Mapeado vs. No Mapeado)

Mapeado en memoria (ejemplo en ensamblador ARM):

ldr r0, =0xE0028000  ; Dirección base del periférico
ldr r1, [r0]        ; Lee el dato del registro en la dirección 0xE0028000

No mapeado en memoria (ejemplo hipotético):

in r1, [0x0300]   ; Lee el dato del puerto de E/S 0x0300 en el registro r1

En el ejemplo mapeado, se usa ldr (load), una instrucción de acceso a memoria. En el no mapeado, se usa in, una instrucción específica de E/S.

E/S en ARM

En la arquitectura ARM, los periféricos de E/S típicamente se mapean en memoria. Esto significa que se accede a los registros de los periféricos como si fueran ubicaciones de memoria. Además, ARM soporta interrupciones, un mecanismo eficiente para que los periféricos notifiquen a la CPU sobre eventos.

Ejemplo de Código en Ensamblador ARM (Vector de Enteros)

El siguiente código en ensamblador ARM ilustra el manejo de un vector de enteros y la comparación de sus elementos con un valor. Aunque no está directamente relacionado con la E/S mapeada o no mapeada, muestra un ejemplo de programación en ensamblador ARM, que a menudo se utiliza en sistemas empotrados donde la gestión de la E/S es crucial.

AREA datos, READWRITE
Vector1 DCD 3,1,2, ... ,31,27  ; Vector de 20 enteros (completa los valores)
numero  DCD 5
boolean DCD 0
iteracciones SPACE 4

AREA prog, CODE, READONLY
ENTRY
    ldr r0, =Vector1
    ldr r1, =numero
    ldr r2, =boolean
    ldr r5, [r1]        ; Carga el valor de 'numero' en r5
    ldr r6, =iteracciones
    mov r3, #0          ; Inicializa el contador

for
    cmp r3, #20         ; Compara el contador con 20
    bge Done            ; Si r3 >= 20, salta a Done
    ldr r4, [r0, r3, LSL #2] ; Carga el elemento del vector (r3 * 4 = desplazamiento)
    cmp r4, r5          ; Compara el elemento del vector con 'numero'
    beq Done1           ; Si son iguales, salta a Done1

sig_dentro_for
    add r3, r3, #1      ; Incrementa el contador
    b for               ; Vuelve al inicio del bucle

Done1
    mov r5, #1          ; Establece 'boolean' a 1
    str r5, [r2]

Done
    str r3, [r6]        ; Guarda el número de iteraciones

fin
    b fin               ; Bucle infinito

END

Explicación del código:

• AREA: Define secciones de memoria (datos y código).
• DCD: Define constantes de palabra (32 bits).
• SPACE: Reserva espacio en memoria.
• ENTRY: Punto de entrada del programa.
• ldr: Carga un valor en un registro.
• mov: Mueve un valor a un registro.
• cmp: Compara dos valores.
• bge: Salta si es mayor o igual que (Branch if Greater than or Equal to).
• beq: Salta si es igual (Branch if Equal to).
• add: Suma.
• str: Almacena un valor en memoria.
• LSL #2: Desplazamiento lógico a la izquierda (multiplica por 4, el tamaño de una palabra).

Este código recorre el vector Vector1, compara cada elemento con el valor almacenado en numero, y si encuentra una coincidencia, establece boolean a 1 y guarda el número de iteraciones realizadas hasta ese momento. El bucle for itera hasta 20 veces o hasta que se encuentra una coincidencia.