Tema 2: Unidad de memoria

2.1. Introducción: qué problema resuelve la unidad de memoria

La memoria guarda las instrucciones de los programas, los datos que usan y los resultados que producen. El procesador la consulta constantemente, así que la rapidez con la que obtiene lo que necesita condiciona el rendimiento de todo el computador.

El problema es que no existe una memoria que lo tenga todo. Las memorias difieren en cuatro aspectos que tiran en direcciones opuestas:

La solución del tema entero es la jerarquía de memoria: combinar memorias rápidas y pequeñas con otras grandes y lentas para conseguir un equilibrio entre rendimiento, capacidad y coste. El resto del tema estudia cada pieza de esa jerarquía:

flowchart LR
    A["2.2-2.3<br/>Conceptos y<br/>características"] --> B["2.4<br/>Jerarquía y<br/>localidad"]
    B --> C["2.5<br/>Tecnologías:<br/>RAM, ROM, flash"]
    C --> D["2.6<br/>Chips, ampliación<br/>y módulos DDR"]
    D --> E["2.7<br/>Memoria caché"]
    E --> F["2.8<br/>Memorias<br/>asociativas"]
    F --> G["2.9<br/>HDD, SSD,<br/>ópticos, cinta"]

2.2. Conceptos básicos de la memoria

2.2.1. Unidades direccionables y direcciones de memoria

La memoria principal puede verse como una matriz de celdas, cada una capaz de guardar un bit. Cada fila tiene una dirección física, $\text{Dir}_F$, que es un entero no negativo que la identifica de forma única.

• Si cada fila tiene $L$ celdas, contiene $L$ bits. Esos bits forman una unidad direccionable: la cantidad mínima de información a la que se accede con una dirección física.
• Hoy la memoria principal suele ser direccionable por bytes: $L = 8$ bits y cada dirección identifica un byte.
• No hay que confundir la dirección (dónde está) con el contenido (qué hay guardado).

Con $n$ bits se forman $2^n$ direcciones distintas. Para numerar $N$ unidades direccionables hace falta el menor $n$ que cumpla $N \leq 2^n$:

$n = \lceil \log_2 N \rceil \qquad\text{y, si } N = 2^n, \qquad n = \log_2 N$

DirF   Contenido (L = 8 bits)
  0    0 1 0 0 1 0 0 0
  1    0 1 0 0 1 0 0 1      cada fila = una unidad direccionable
  2    1 0 1 0 1 0 1 0      cada número de la izquierda = su dirección física
  ...
255    0 1 0 0 1 0 1 0      N = 256 unidades -> n = 8 bits (0000 0000 a 1111 1111)

2.2.2. Palabras y longitud de palabra

Una palabra es el conjunto de bits que el procesador maneja como una unidad en determinadas operaciones. Su número de bits es la longitud de palabra $L_p$ (16, 32 o 64 bits, según la arquitectura).

La longitud de palabra no tiene por qué coincidir con la de la unidad direccionable. Una palabra puede ocupar varias unidades consecutivas, cada una con su propia dirección:

$\frac{L_p}{L} = \text{unidades direccionables por palabra} \qquad \text{ej.: } \frac{32}{8} = 4$

2.2.3. Organización y capacidad de memoria

Una memoria se describe por su organización $N \times L$: $N$ unidades direccionables de $L$ bits. Por ejemplo, $1024 \times 8$ bits son 1024 unidades de 8 bits.

$C = N \cdot L \ \text{bits}$

La función suelo $\lfloor x \rfloor$ da el mayor entero menor o igual que $x$: $\lfloor 3.7 \rfloor = 3$. Por ejemplo, con $C = 80$ bits y $L_p = 32$: caben 2 palabras y sobran 16 bits, insuficientes para otra.

Hay que cuidar los prefijos: $1\text{ kB} = 1000$ B, pero $1\text{ KiB} = 1024$ B. Y distinguir $b$ (bit) de $B$ (byte).

2.3. Características de las memorias

2.3.1. Operaciones de lectura y escritura

La unidad de transferencia es la cantidad de información que se transfiere entre la memoria y otro componente en una operación de acceso. Su longitud es $L_T$. Hay que distinguir tres longitudes, que no tienen por qué coincidir:

$L_T$ tampoco tiene por qué coincidir con el ancho del bus de datos: si $L_T = 64$ bits y el bus es de 32, se envía en dos transferencias sucesivas; con bus de 64, en una.

2.3.2. Parámetros de rendimiento

Tiempo de acceso, $t_a$: intervalo desde que se inicia una lectura o escritura hasta que se completa. En lectura, hasta que los datos están disponibles. Puede ser distinto en lectura y en escritura y, en algunas memorias, depender de la posición; entonces se usa su valor medio.

Tiempo de ciclo, $t_c$: intervalo mínimo entre el inicio de dos accesos consecutivos. En una memoria sencilla sin solapamiento:

$t_c \geq t_a$

porque, tras entregar el dato, la memoria puede necesitar un tiempo extra, $t_c - t_a$, para quedar preparada.

Petición                   Información               Memoria preparada
de lectura                 disponible                para un nuevo acceso
    |<-------- t_a ---------->|                              |
    |<--------------------------- t_c ---------------------->|

Sin solapamiento, la frecuencia máxima de acceso depende de $t_c$, no de $t_a$:

$f_{\max} = \frac{1}{t_c} \quad \text{(accesos/s)}$

Velocidad de transferencia, $v_T$: información transferida por unidad de tiempo. Depende de cuánto se transfiere en cada acceso ($L_T$) y de cuántos accesos se hacen por segundo:

$v_T = \frac{N}{T} \qquad\qquad v_{T,\max} = L_T \cdot f_{\max} = \frac{L_T}{t_c}$

Una de esas limitaciones es el ancho de banda del bus: si la memoria da 800 MB/s pero el bus solo admite 400 MB/s, entre ambos no se superan 400 MB/s (y la efectiva puede ser incluso menor).

2.3.3. Métodos de acceso a la información

El método de acceso es el procedimiento para localizar la información y leerla o escribirla. Los apuntes usan el término posición de almacenamiento, más general que unidad direccionable, porque no presupone que se pueda llegar a ella directamente con una dirección.

Tres matices que caen en examen:

• "Aleatorio" no significa al azar: significa que se llega a cualquier unidad sin recorrer las anteriores (a la dirección 1000 sin pasar por 0, 1, ..., 999).
• Acceso aleatorio no es lo mismo que "RAM": un SSD también permite acceso aleatorio. La palabra RAM se reserva para ciertas memorias de semiconductores de lectura y escritura.
• Aleatorio frente a asociativo: en el aleatorio se da una dirección y se obtiene el contenido; en el asociativo se da un contenido y se obtienen las posiciones que coinciden (puede haber una, varias o ninguna).

2.3.4. Clasificación de las memorias

Los criterios no son excluyentes: una misma memoria pertenece a varias categorías a la vez.

flowchart TB
    M["Memorias"] --> V["Volatilidad"]
    M --> T["Tecnología"]
    M --> F["Localización y función"]
    M --> AC["Método de acceso<br/>(2.3.3)"]
    V --> V1["Volátiles<br/>RAM: SRAM, DRAM"]
    V --> V2["No volátiles<br/>ROM, flash, HDD, SSD,<br/>ópticos, cintas"]
    T --> T1["Semiconductores<br/>SRAM, DRAM, ROM,<br/>PROM, EPROM, EEPROM, flash"]
    T --> T2["Magnéticas<br/>HDD, cintas"]
    T --> T3["Ópticas<br/>CD, DVD, Blu-ray"]
    F --> F1["Interna<br/>registros, caché"]
    F --> F2["Principal<br/>DRAM"]
    F --> F3["Secundaria o externa<br/>HDD, SSD, ópticos, cintas"]

Según la volatilidad. La volatilidad indica si la información se pierde al cortar la alimentación. Las volátiles (RAM de la memoria principal) la pierden; las no volátiles (ROM, flash, HDD, SSD, CD, DVD, Blu-ray, cintas) la conservan. La volatilidad no determina por sí sola la velocidad ni el método de acceso: RAM y SSD son ambos de acceso aleatorio, pero solo la RAM es volátil.

Según la tecnología. Semiconductores (circuitos electrónicos), magnéticas (propiedades magnéticas de un material) y ópticas (lectura con láser).

Según su localización y función:

Dos notas de los apuntes: un SSD es memoria secundaria por su función aunque sea de semiconductores, y "memoria externa" no implica que esté físicamente fuera del computador.

2.4. Jerarquía de memoria

La jerarquía de memoria organiza los distintos tipos de memoria en niveles ordenados según velocidad, capacidad y coste, para dar acceso rápido y mucha capacidad a un coste razonable.

                 /\          Velocidad  +      Capacidad  -      Coste/bit  +
                /  \
               /Reg.\
              /------\
             / Caché  \
            /----------\
           /  Memoria   \
          /  principal   \
         /----------------\
        / Memoria externa  \     Velocidad  -      Capacidad  +      Coste/bit  -
       /--------------------\

Al bajar en la jerarquía aumenta la capacidad y disminuyen la velocidad y el coste por bit. Al subir, lo contrario.

2.4.1. Principio de localidad

La jerarquía funciona porque el procesador no accede de forma uniforme a la memoria: tiende a repetir posiciones y a usar posiciones cercanas.

Gracias a la localidad, una memoria rápida y pequeña que guarda lo usado recientemente y lo que está cerca resuelve una proporción alta de los accesos, y se reduce el tiempo medio de acceso.

2.4.2. Transferencia de información entre niveles

Los niveles rápidos guardan una parte de lo que hay en los lentos. Si el dato no está en el nivel rápido, se busca en el inferior. La transferencia entre niveles se hace en bloques:

• Entre memoria principal y caché: bloques de palabras consecutivas.
• Entre memoria secundaria y principal: bloques de un número determinado de bytes.

Traer el bloque entero aprovecha la localidad espacial: junto al dato pedido llegan los vecinos, y el siguiente acceso cercano ya se resuelve en el nivel rápido. Si además se reutiliza lo traído, se aprovecha la localidad temporal.

2.5. Memorias de semiconductores

Son dispositivos electrónicos que guardan información binaria en celdas fabricadas con semiconductores (sobre todo silicio). Se implementan como circuitos integrados: un chip protegido por un encapsulado con terminales externos (pines).

Toda celda, sea cual sea su tecnología, cumple tres propiedades:

1. Tiene dos estados distinguibles, estables o semiestables, para representar 0 y 1.
2. Se puede escribir para fijar su estado (algunas tecnologías solo una vez).
3. Se puede leer para conocer su estado.

Funcionalmente, una celda tiene tres tipos de conexiones:

2.5.1. Memorias RAM

Las RAM permiten leer y escribir directamente durante el funcionamiento normal, mediante señales eléctricas, sin procedimientos especiales de programación o borrado. Lo que las distingue no es el acceso aleatorio (las ROM también lo tienen) sino que están pensadas para leer y escribir con normalidad. Las convencionales son volátiles.

SRAM (RAM estática). Guarda cada bit en un circuito biestable, que tiene dos estados estables y los mantiene mientras hay alimentación.

• Celda típica de 6 transistores: 4 forman el biestable y 2 actúan como interruptores de acceso.
• Escritura: se pone el valor en las líneas de datos y se activa la selección.
• Lectura: se activa la selección y se lee el valor sin alterar el biestable: lectura no destructiva.
• No necesita refresco: de ahí lo de "estática".

DRAM (RAM dinámica). Guarda cada bit como la carga de un condensador.

• Celda típica de 1 transistor y 1 condensador. Normalmente, carga suficiente es 1 y ausencia de carga es 0.
• Escritura: se activa el transistor y se carga o descarga el condensador.
• Lectura: la carga produce una pequeña variación de tensión que detecta un amplificador de detección. La lectura altera la carga: es destructiva y hay que restaurar el valor.
• Las corrientes de fuga descargan el condensador poco a poco incluso con alimentación, así que hay que hacer refresco periódico: de ahí lo de "dinámica".

La densidad de almacenamiento es la información que cabe por unidad de superficie del chip (bit/mm², Mibit/mm²...). Como la celda DRAM ocupa menos que la SRAM, la DRAM es más densa y más barata por bit.

2.5.2. Memorias ROM

Las ROM (Read Only Memory) son memorias de semiconductores no volátiles. El nombre viene de las primeras, cuyo contenido se fijaba en fábrica y solo se podía leer. Después aparecieron variantes programables e incluso borrables que se siguen incluyendo en la familia aunque no sean estrictamente "de solo lectura". Se usan para información que debe conservarse mucho tiempo sin alimentación.

ROM de máscara. El contenido se fija durante la fabricación mediante la estructura de las celdas y no se puede cambiar.

• Ventaja: coste unitario bajo en tiradas grandes.
• Inconvenientes: coste inicial de preparar la fabricación, y cualquier error obliga a fabricar chips nuevos.
• Uso: programas y datos fijos en microcontroladores, calculadoras y aparatos fabricados en masa. Desde la década de 1960.

PROM (ROM programable). Se programa eléctricamente una sola vez después de fabricarla, modificando de forma irreversible conexiones internas. No se puede borrar ni reprogramar.

• Ventaja frente a la de máscara: el contenido se pone después de fabricar, útil para tiradas pequeñas.
• Uso actual del principio: números de serie, datos de identificación y parámetros que no deben cambiar. Desde la década de 1970.

EPROM (ROM programable y borrable). Se programa eléctricamente y se borra con luz ultravioleta.

• Usa transistores de puerta flotante: una región conductora aislada donde quedan atrapadas cargas; su presencia o ausencia representa 0 o 1.
• Programar es introducir carga en las puertas flotantes; la carga se mantiene sin alimentación.
• Borrar es exponer el chip a ultravioleta, lo que elimina las cargas. El borrado afecta a todo el contenido y normalmente hay que sacar el chip del aparato. Por eso llevan una ventana transparente en el encapsulado.
• Comercializadas desde 1971; desplazadas después por EEPROM y flash.

EEPROM (ROM programable y borrable eléctricamente). Usa también puerta flotante, pero tanto escribir como borrar se hace con señales eléctricas, sin sacar el chip.

• Permite modificar selectivamente, normalmente por bytes, sin borrar todo.
• Escribir y borrar es más lento que leer, y las celdas soportan un número limitado de ciclos de escritura y borrado por desgaste.
• Uso: pequeñas cantidades de datos modificables (configuración, calibración, identificación). Desde finales de los 70.
• Su estructura limita la densidad, lo que impulsó la aparición de la flash.

flowchart LR
    A["ROM de máscara<br/>fijada en fábrica"] -->|"programar después<br/>de fabricar"| B["PROM<br/>una sola vez"]
    B -->|"poder borrar"| C["EPROM<br/>borrado UV, todo"]
    C -->|"borrado eléctrico<br/>y selectivo"| D["EEPROM<br/>por bytes"]
    D -->|"borrado por bloques:<br/>más densidad, menos coste"| E["Flash"]

2.5.3. Memorias flash

Las flash son memorias de semiconductores no volátiles, modificables eléctricamente, que evolucionan de la EEPROM. Su rasgo clave es que se borran por bloques de celdas, no por bytes. Eso simplifica los circuitos de borrado y permite más densidad y menos coste por bit que la EEPROM.

En la flash NAND las celdas se agrupan en páginas (unidad de lectura y programación) y las páginas en bloques (unidad de borrado):

Leer es más rápido que programar y borrar. Las celdas soportan un número limitado de ciclos de programación y borrado; para alargar la vida útil se usa la nivelación del desgaste (wear leveling), que reparte las operaciones entre bloques.

Tiempos orientativos: leer una página, decenas de µs; programarla, de cientos de µs a varios ms; borrar un bloque, varios ms. Páginas de varios KiB y bloques de cientos de páginas; chips de varios Gib, incluso 1 Tib o más.

NOR frente a NAND:

Bits por celda. Usando varios niveles de carga, una celda NAND guarda más de un bit. Con $k$ bits por celda hacen falta $2^k$ estados distinguibles:

Más bits por celda dan más densidad y menos coste por bit, pero los estados de carga son más difíciles de distinguir: programar tarda más y la celda aguanta menos ciclos. SLC ofrece más resistencia y rapidez; MLC, TLC y QLC más capacidad y menor coste.

2.6. Módulos y organización de la memoria principal

2.6.1. Circuitos integrados de memoria

Un circuito integrado (chip) de memoria contiene un conjunto de celdas y los circuitos auxiliares para seleccionar unidades direccionables y leer o escribir. Lógicamente se organiza como $N \times L$ bits:

$C = N \cdot L \text{ bits}$

Organización interna. La organización lógica no tiene por qué coincidir con la física. Las celdas forman una matriz de filas y columnas, y unos decodificadores seleccionan la fila y la columna a partir de los bits de dirección. Así no hace falta una conexión externa por celda.

flowchart LR
    DIR["n líneas de<br/>dirección"] --> DF["Decodificador<br/>de filas"]
    DIR --> DC["Decodificador<br/>de columnas"]
    DF --> MAT["Matriz de celdas<br/>de memoria"]
    DC --> MAT
    CTRL["Control"] --> RW["Circuitos de<br/>lectura y escritura"]
    MAT <--> RW
    RW <--> DAT["L líneas<br/>de datos"]

Además, las DRAM incluyen circuitos de refresco. En cada operación se transfieren $L$ bits: un chip de $2^{20} \times 8$ mueve 8 bits por acceso.

Encapsulados y terminales. Los terminales (pines) se agrupan por función:

En el ejemplo de los apuntes, un DIP de 24 pines (dos hileras paralelas) de una DRAM $4\text{M} \times 4$ bits tiene:

En la notación tradicional de chips, "M" significa $2^{20}$ (lo que la norma llama Mi), así que $4\text{M} = 2^{22}$ unidades: harían falta 22 bits de dirección, pero solo hay 11 terminales. Lo permite el direccionamiento multiplexado.

Hoy los chips DRAM de los módulos usan encapsulado BGA (Ball Grid Array): una matriz de bolitas de soldadura en la cara inferior, que permite muchas más conexiones en poca superficie que el DIP.

Direccionamiento multiplexado en DRAM. Para reducir terminales, la dirección se divide en dirección de fila y dirección de columna, y ambas se envían sucesivamente por los mismos terminales:

sequenceDiagram
    participant C as Controlador
    participant D as Chip DRAM 2^22 x 4
    C->>D: Dirección de fila (11 bits) por A0-A10
    C->>D: Activa RAS: el chip captura y guarda la fila
    C->>D: Dirección de columna (11 bits) por A0-A10
    C->>D: Activa CAS: el chip captura la columna
    D-->>C: Datos de la unidad seleccionada (D0-D3)

2.6.2. Ampliación de la capacidad de memoria

Se quiere construir una memoria $C = N \times L$ con chips de capacidad base $C_0 = N_0 \times L_0$. Hay tres casos.

Caso 1. Ampliación del número de bits por unidad direccionable

$N = N_0$ y $L > L_0$: mismas direcciones, más bits por dirección. Se ponen $r$ chips en paralelo:

$r = \left\lceil \frac{C}{C_0} \right\rceil = \left\lceil \frac{L}{L_0} \right\rceil$

             A9..A0, selección, lectura, escritura (comunes)
        +------------+------------+------------+------------+
        |   CI 0     |   CI 1     |   CI 2     |   CI 3     |
        |  2^10 x 8  |  2^10 x 8  |  2^10 x 8  |  2^10 x 8  |
        +-----+------+-----+------+-----+------+-----+------+
              |            |            |            |
           D7..D0      D15..D8     D23..D16     D31..D24
        \____________ bus de datos de 32 bits ______________/
              Los cuatro chips actúan a la vez en cada acceso

Caso 2. Ampliación del número de unidades direccionables

$L = L_0$ y $N > N_0$: más direcciones, mismos bits. Se usan $q$ chips:

$q = \left\lceil \frac{C}{C_0} \right\rceil = \left\lceil \frac{N}{N_0} \right\rceil$

Ahora no actúan todos a la vez: hay que elegir el chip que contiene la dirección. Para eso se usa un decodificador: un circuito combinacional de $k$ entradas y hasta $2^k$ salidas que, para cada combinación de entrada, activa una salida distinta.

Tabla de verdad de un decodificador 2 a 4 con salidas activas a nivel alto (activa = 1). Existen también salidas activas a nivel bajo (activa = 0).

Si $N_0 = 2^{n_0}$ y $N = 2^n$, la dirección se parte en dos:

 A(n-1) ... A(n0)  |  A(n0-1) ... A1 A0
 \_______________/    \________________/
  p = n - n0 bits      n0 bits
  -> decodificador     -> dirección dentro del chip
  (elige el chip)         (a todos los chips en paralelo)

flowchart LR
    A["A11 A10"] --> DEC["Decodificador<br/>2 a 4"]
    DEC -->|S0| C0["CI 0<br/>2^10 x 8"]
    DEC -->|S1| C1["CI 1<br/>2^10 x 8"]
    DEC -->|S2| C2["CI 2<br/>2^10 x 8"]
    DEC -->|S3| C3["CI 3<br/>2^10 x 8"]
    B["A9..A0"] --> C0 & C1 & C2 & C3
    C0 & C1 & C2 & C3 <--> BD["Bus de datos<br/>de 8 bits"]

Caso 3. Ampliación simultánea de ambas magnitudes

$N > N_0$ y $L > L_0$. Se combinan los dos casos: primero grupos de $r$ chips en paralelo para la anchura, y luego $q$ grupos seleccionados con un decodificador.

$r = \left\lceil \frac{L}{L_0} \right\rceil \qquad q = \left\lceil \frac{N}{N_0} \right\rceil \qquad N_{CI} = q \cdot r$

Cada salida del decodificador habilita todos los chips de un grupo. Dentro del grupo, cada chip aporta bits distintos; los chips que aportan el mismo bit en grupos distintos comparten esa línea del bus, y solo el grupo seleccionado tiene sus salidas habilitadas.

2.6.3. Módulos de memoria principal

Un módulo de memoria es un conjunto de chips montados en una placa de circuito impreso con las conexiones para comunicarse con el resto del computador. Permite ampliar o cambiar la memoria sin tocar la placa base.

Organización. La anchura de datos del módulo es el número de bits que transfiere a la vez; en PC suele ser 64 bits (algunos módulos añaden bits para detección y corrección de errores).

Un rango (rank) es un conjunto de chips que se seleccionan juntos para leer y escribir. La relación con la ampliación es directa:

Módulo de memoria
+---------------------------------------------------------------+
| Rango 0: CI0 CI1 CI2 CI3 CI4 CI5 CI6 CI7  (8 x 8 bits = 64)   |  2^10 x 64 bits = 8 KiB
| Rango 1: CI0 CI1 CI2 CI3 CI4 CI5 CI6 CI7  (8 x 8 bits = 64)   |  2^10 x 64 bits = 8 KiB
+---------------------------------------------------------------+
  Capacidad total: 16 KiB      Anchura de datos: 64 bits (no 128)

Formatos. Los módulos se conectan a la placa base:

La compatibilidad depende del formato y de las características eléctricas y la tecnología: dos módulos de formato parecido no son necesariamente intercambiables. En algunos portátiles y móviles los chips van soldados a la placa.

Memorias DDR SDRAM.

Una señal de reloj tiene dos tipos de transición o flanco: ascendente (de nivel bajo a alto) y descendente (de alto a bajo). DDR transfiere datos en ambos.

          ____      ____      ____
reloj    |    |    |    |    |    |
     ____|    |____|    |____|    |____
         ^    v    ^    v    ^    v       ^ flanco ascendente   v flanco descendente
datos    D0   D1   D2   D3   D4   D5      DDR: un dato en cada flanco
         |<-- Tck -->|

El controlador de memoria (hoy integrado en el procesador) gestiona las lecturas y escrituras y genera las señales para los chips. Se comunica con los módulos por el bus de memoria (datos, direcciones, control y reloj), que es distinto del bus del sistema. El reloj de la interfaz de memoria es distinto del reloj interno del procesador.

flowchart LR
    subgraph P ["Procesador"]
        N["Núcleos y<br/>otros componentes"] --- CA["Memoria caché"]
        CA --- CM["Controlador<br/>de memoria"]
    end
    CM <-->|"Bus de memoria"| MOD["Módulos<br/>DDR SDRAM"]
    N <-->|"Bus del sistema"| ES["Resto del sistema"]

La tasa de transferencia es el número de transferencias por unidad de tiempo (en MT/s, millones de transferencias por segundo). En DDR:

$R_t = \frac{N_t}{T} \qquad R_t = 2 f_{ck} \qquad BW = R_t \cdot A$

donde $f_{ck}$ es la frecuencia del reloj de la interfaz y $A$ la anchura de datos del bus en bits. Frecuencia (MHz) y tasa (MT/s) son magnitudes distintas: 1600 MHz dan 3200 MT/s.

Cada generación mejora tasa, capacidad de chips y eficiencia, y no son intercambiables entre sí.

Varios módulos y canales. Un canal de memoria es una interfaz del controlador con su propio bus, a la que se conectan uno o varios módulos; el controlador gestiona cada canal de forma independiente.

Ejemplos de los apuntes: un sobremesa con 2 canales y 2 módulos por canal (4 módulos); procesadores de servidor con 12 canales y 2 módulos por canal (24 módulos).

(a) Un canal                       (b) Dos canales
Controlador ==== M1 M2 M3 M4       Controlador == Canal 0 == M1 M2
                 (bus compartido)              == Canal 1 == M3 M4

Modelo simplificado de módulos independientes. Varios módulos comparten el bus de un canal. Cada operación ocupa el bus un tiempo $t_{bus}$; después, el módulo sigue trabajando por dentro $t_{int}$ sin usar el bus, y ese hueco lo puede aprovechar otro módulo: es el solapamiento.

Cuando $t_c/t_{bus}$ es entero, las operaciones que se completan por ciclo y la velocidad máxima son:

$N_{op} = \min\left(N_{mod},\ \frac{t_c}{t_{bus}}\right) \qquad v_{T,\max} = \frac{N_{op} \cdot L_T}{t_c}$

Ejemplo 2.12 ($t_{bus} = 50$ ns, $t_{int} = 200$ ns, $L_T = 8$ B), cada carácter son 25 ns; # es bus ocupado y - trabajo interno:

t (ns)  0   100 200 300 400 500
M1      ##--------##--------##
M2        ##--------##--------##
M3          ##--------##--------##
M4            ##--------##--------##
BUS     ########..########..########
        4 módulos: el bus queda libre 50 ns de cada 250

Añadir módulos mejora la velocidad hasta saturar el bus; a partir de ahí no aporta nada. Las DRAM actuales aplican la misma idea dentro del chip con los bancos de memoria, subdivisiones que funcionan de forma parcialmente independiente (no confundir con los rangos).

Organización entrelazada (solo aparece en los ejercicios). El ejercicio 2.18 plantea elegir el chip con los bits menos significativos, para que direcciones consecutivas caigan en chips distintos de forma cíclica:

Con entrelazado, C88, C89, C8A y C8B van a CI 0, 1, 2 y 3, todas con dirección interna 322. Puede facilitar el solapamiento, pero no garantiza por sí solo más rendimiento.

2.7. Memoria caché

2.7.1. Concepto y funcionamiento

El procesador es mucho más rápido que la DRAM y tendría que esperar continuamente. La memoria caché es una memoria pequeña y rápida (SRAM), situada funcionalmente entre el procesador y la memoria principal e integrada en el procesador, que guarda copias de bloques de memoria principal (conjuntos de unidades direccionables consecutivas).

Suele haber tres niveles: L1 (el más cercano al núcleo, el más pequeño y rápido), L2 y L3 (el más grande y lento de los tres, pero mucho más rápido que la memoria principal).

flowchart TD
    A["El procesador solicita<br/>una dirección"] --> B{"¿Hay en el nivel consultado<br/>una copia del bloque que<br/>contiene esa dirección?"}
    B -->|"Sí: acierto"| C["Se lee de la caché<br/>y se entrega al procesador"]
    B -->|"No: fallo"| D["Gestión del fallo:<br/>traer el bloque del nivel inferior"]

Su eficacia se basa en el principio de localidad: lo usado recientemente y lo cercano tiene mucha probabilidad de volver a usarse.

2.7.2. Organización de la memoria caché

Bloques de memoria principal. Para la caché, la memoria principal se divide en bloques de $S_B$ unidades direccionables consecutivas. Si la memoria tiene $C_{MP}$ unidades:

$N_{BP} = \left\lceil \frac{C_{MP}}{S_B} \right\rceil \qquad j = 0, 1, \ldots, N_{BP} - 1 \qquad n = \lceil \log_2 C_{MP} \rceil$

(Si $C_{MP}$ no es múltiplo de $S_B$, el último bloque se considera completo aunque le falten posiciones.)

Una dirección de $n$ bits se divide en dos campos:

DirMP  |      Bloque j (f bits)       |   Desplazamiento (d bits)   |
        \____ número del bloque ____/   \__ posición p dentro de él _/

$f = \lceil \log_2 N_{BP} \rceil \qquad d = \log_2 S_B \qquad n = f + d \qquad \text{Dir}_{MP} = j \cdot S_B + p$

con $p$ entre $0$ y $S_B - 1$. Con $f$ bits caben $2^f$ números de bloque, que pueden ser más que los $N_{BP}$ existentes; entonces algunas combinaciones no corresponden a ningún bloque.

Equivalentemente, a partir de la dirección:

$j = \left\lfloor \frac{\text{Dir}_{MP}}{S_B} \right\rfloor \qquad p = \text{Dir}_{MP} \bmod S_B$

Líneas de caché. La caché se organiza en líneas; cada una guarda un bloque, así que su capacidad de datos es $S_B$:

$N_{LC} = \frac{C_{MC}}{S_B} \qquad i = 0, \ldots, N_{LC} - 1 \qquad b = \lceil \log_2 N_{LC} \rceil$

(Aquí no hace falta redondear: la capacidad de datos de la caché siempre es múltiplo del bloque.)

Además de los datos, la caché tiene un directorio con una entrada por línea:

La capacidad de una caché se refiere solo a sus datos, sin contar el directorio. Como $N_{LC} \ll N_{BP}$, solo caben a la vez unos pocos bloques.

                Directorio           Zona de datos (S_B = 8 B)
             +---+----------+     +---+---+---+---+---+---+---+---+
Línea i = 0  | V | Etiqueta |     | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
             +---+----------+     +---+---+---+---+---+---+---+---+
Línea i = 1  | V | Etiqueta |     | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
             +---+----------+     +---+---+---+---+---+---+---+---+

2.7.3. Métodos de correspondencia

Como no caben todos los bloques, hay que decidir en qué línea puede ir cada bloque. Esa regla es la función de correspondencia.

flowchart LR
    subgraph D ["Directa"]
        BD["Bloque j"] -->|"una línea fija<br/>i = j mod NLC"| LD["Línea i"]
    end
    subgraph T ["Totalmente asociativa"]
        BT["Bloque j"] -->|"cualquier línea"| LT["Cualquier línea"]
    end
    subgraph C ["Por conjuntos"]
        BC["Bloque j"] -->|"un conjunto fijo<br/>q = j mod Q"| LC["Cualquier línea<br/>del conjunto q"]
    end

Correspondencia directa

Cada bloque tiene asignada una única línea:

$i = j \bmod N_{LC}$

Los bloques con el mismo resto comparten línea y no pueden estar a la vez en la caché. El campo Bloque $j$ se divide en Etiqueta y Línea $i$:

DirMP  |  Etiqueta (e)  |  Línea i (b)  |  Desplazamiento (d)  |
        \_____ Bloque j (f bits) ______/

$b = \log_2 N_{LC} \qquad d = \log_2 S_B \qquad n = e + b + d \qquad e = n - (b + d)$

La etiqueta distingue entre los bloques que comparten línea.

Funcionamiento:

1. El campo Línea $i$ indica en qué línea buscar.
2. Se comprueba en el directorio si $V = 1$ y la etiqueta guardada coincide con la de la dirección. Si se cumplen ambas, acierto; si no, fallo.
3. Acierto: el desplazamiento localiza la unidad dentro del bloque. Fallo de lectura: se trae el bloque, se guarda en su línea (sustituyendo al anterior), se actualizan etiqueta y $V$, y se entrega el dato. En un fallo de escritura decide la política de asignación.

Correspondencia totalmente asociativa

Cualquier bloque puede ir a cualquier línea. Si hay líneas libres, se usa una; si no, hay que elegir cuál sustituir con una política de reemplazo:

LRU exacto necesita mucha información de control cuando hay muchas líneas, por eso en la práctica se usan aproximaciones más sencillas.

La dirección no tiene campo de línea: la etiqueta es el número de bloque completo.

DirMP  |        Etiqueta (e = f bits)        |  Desplazamiento (d)  |

$e = f = \lceil \log_2 N_{BP} \rceil \qquad n = e + d \qquad e = n - d$

Funcionamiento: se compara la etiqueta simultáneamente con la de todas las líneas válidas. Si alguna coincide, acierto y se usa el desplazamiento. Si no, fallo: se trae el bloque a una línea libre o a la que indique la política de reemplazo, y se actualizan etiqueta y $V$.

Correspondencia asociativa por conjuntos

Es un híbrido. Las $N_{LC}$ líneas se dividen en $Q$ conjuntos de $r$ líneas:

$Q = \frac{N_{LC}}{r} \qquad q = j \bmod Q \qquad q = 0, \ldots, Q - 1$

$r$ es el grado de asociatividad; la caché se llama asociativa de $r$ vías. En cachés comerciales, $Q$ es potencia de 2.

El campo Bloque $j$ se divide en Etiqueta y Conjunto $q$:

DirMP  |  Etiqueta (e)  |  Conjunto q (c)  |  Desplazamiento (d)  |
        \______ Bloque j (f bits) _______/

$c = \log_2 Q \qquad n = e + c + d \qquad e = n - (c + d)$

Funcionamiento: el campo Conjunto elige el conjunto; se compara la etiqueta solo con sus $r$ líneas. Si alguna es válida y coincide, acierto. Si no, fallo: el bloque va a una línea libre de ese conjunto o, si están todas ocupadas, se aplica la política de reemplazo solo dentro del conjunto, aunque haya líneas libres en otros.

Caché de 4 líneas, r = 2 (2 vías) -> Q = 2 conjuntos
              +-----------+
Conjunto q=0  | Línea i=0 |  <- bloques pares   (j mod 2 = 0)
              | Línea i=1 |
              +-----------+
Conjunto q=1  | Línea i=2 |  <- bloques impares (j mod 2 = 1)
              | Línea i=3 |
              +-----------+

El grado $r$ marca el compromiso entre sencillez y flexibilidad:

$r = 1 \Rightarrow \text{directa} \qquad\qquad r = N_{LC} \Rightarrow \text{totalmente asociativa}$

Comparación de los métodos

DirMP (n bits)            |          Bloque j (f)            | Despl. (d) |
F. C. directa             |  Etiqueta (e)  |  Línea i (b)    | Despl. (d) |
F. C. totalmente asoc.    |          Etiqueta (e = f)        | Despl. (d) |
F. C. por conjuntos       |  Etiqueta (e)  |  Conjunto q (c) | Despl. (d) |

El método de correspondencia se fija al diseñar el hardware: el usuario no puede cambiarlo.

2.7.4. Políticas de escritura

Al escribir puede haber copias del mismo bloque en varios niveles, así que hay que decidir dos cosas.

1) Cómo se actualiza la memoria principal cuando se modifica un dato que está en caché:

Para paliar el tráfico de la escritura inmediata se usan búferes de escritura (write buffers): guardan direcciones y datos pendientes de escribir en memoria, y el procesador sigue sin esperar.

En escritura diferida, cada línea tiene un bit de modificación (dirty bit) $M$:

2) Qué hacer si se escribe en un bloque que no está en la caché (fallo de escritura):

Las dos decisiones son independientes (cuatro combinaciones), pero las más habituales son inmediata sin asignación y diferida con asignación.

flowchart TD
    W["Escritura del procesador"] --> H{"¿Acierto?"}
    H -->|Sí| P1{"Política de<br/>actualización"}
    P1 -->|Inmediata| WT["Escribir en caché<br/>y en memoria principal"]
    P1 -->|Diferida| WB["Escribir solo en caché<br/>y poner M = 1"]
    H -->|No| P2{"Política de<br/>asignación"}
    P2 -->|Con asignación| WA["Traer el bloque a la caché<br/>y escribir en ella"]
    P2 -->|Sin asignación| NWA["Escribir directamente<br/>en memoria principal"]

2.7.5. Jerarquía de memorias caché

Los tiempos se dan en ciclos: el mismo número de ciclos son tiempos distintos en procesadores de distinta frecuencia. El de L1 corresponde a la caché de datos. La búsqueda va de L1 a L2, a L3 y a memoria principal; el bloque recuperado puede guardarse en uno o varios niveles.

En procesadores multinúcleo:

+--------------------------------- Procesador ----------------------------------+
| Núcleo 1         Núcleo 2         Núcleo 3         Núcleo 4                    |
| [L1-I][L1-D]     [L1-I][L1-D]     [L1-I][L1-D]     [L1-I][L1-D]                |
| [ Caché L2 ]     [ Caché L2 ]     [ Caché L2 ]     [ Caché L2 ]   (privadas)  |
| [                      Caché L3 compartida                       ]             |
| [                    Controlador de memoria                      ]             |
+-------------------------------------+-----------------------------------------+
                                      | bus de memoria
                              [ Memoria principal ]

Las cachés privadas plantean el problema de la coherencia de caché: si un núcleo modifica un dato, las copias de los demás quedan desactualizadas. Los mecanismos de coherencia controlan las modificaciones y, si hace falta, invalidan o actualizan las otras copias.

2.7.6. Rendimiento de la memoria caché

Con $N_T$ accesos, $N_A$ aciertos y $N_F$ fallos ($N_T = N_A + N_F$):

$h = \frac{N_A}{N_T} \qquad m = \frac{N_F}{N_T} \qquad h + m = 1$

Una $h$ alta (por ejemplo, 0.95) es favorable, pero no garantiza por sí sola un buen rendimiento: también cuentan los tiempos y la penalización por fallo.

Tiempo medio de acceso (AMAT, $t_{am}$). Con $t_A$ (tiempo con acierto) y $t_F$ (tiempo con fallo), el tiempo total es $T_T = N_A t_A + N_F t_F$ y, dividiendo entre $N_T$:

$t_{am} = \frac{T_T}{N_T} = h\,t_A + (1 - h)\,t_F$

Todos los accesos empiezan consultando la caché, de tiempo $t_c$. La penalización por fallo $P_F$ es el tiempo adicional que añade un fallo:

$t_A = t_c \qquad t_F = t_c + P_F \qquad\Longrightarrow\qquad t_{am} = t_c + (1 - h)\,P_F = t_c + m\,P_F$

Jerarquía de cachés. Con L1 y L2 consultadas sucesivamente, $t_1$ y $t_2$ sus tiempos y $t_M$ el tiempo adicional de la memoria principal:

$P_{F1} = t_2 + m_2\,t_M \qquad t_{am} = t_1 + m_1\,(t_2 + m_2\,t_M)$

Interpretación: todos pagan $t_1$; una fracción $m_1$ paga además $t_2$; y de esos, una fracción $m_2$ paga además $t_M$.

Con tres niveles, el mismo razonamiento anidado:

$t_{am} = t_1 + m_1\big(t_2 + m_2\,(t_3 + m_3\,t_M)\big)$

Es un modelo simplificado (consulta secuencial y tiempos acumulados); en procesadores reales puede ser más complejo.

2.8. Memorias asociativas

2.8.1. Concepto y funcionamiento

Una memoria asociativa o memoria direccionable por contenido (CAM) busca la información por su contenido, no por una dirección. Compara un valor de búsqueda con todas las posiciones a la vez, gracias a circuitos de comparación incorporados en el hardware, sin recorrerlas una a una.

flowchart LR
    A["1. Se introduce<br/>el valor de búsqueda"] --> B["2. Comparación<br/>simultánea con las<br/>posiciones habilitadas"]
    B --> C["3. Detección de<br/>coincidencias"]
    C --> D["4. Obtención del resultado<br/>(posiciones o información<br/>asociada)"]

Una búsqueda puede dar una, varias o ninguna coincidencia.

2.8.2. Organización

Elementos funcionales:

Organización clásica con registros auxiliares. Con una matriz de $n$ entradas de $m$ bits:

          Registro argumento (m)    Registro máscara (m)
                    |                      |
                    v                      v
        +---------------------------------------+   Validez   Marca
        |   Matriz de celdas de memoria         |   (n bits)  (n bits)
        |   asociativa: n entradas x m bits     |<--   V   -->  M
        +---------------------------------------+
                    |
                    v
          Registro de salida (m)

Formalmente, si $W_{ij}$ es el bit $j$ de la entrada $i$:

$M_i = V_i \cdot \prod_{j}\left(\overline{K_j} + \overline{A_j \oplus W_{ij}}\right)$

Cada factor vale 1 si la columna no se compara ($K_j = 0$) o si el bit coincide ($A_j = W_{ij}$).

Otras operaciones:

2.8.3. Aplicaciones

Se usan cuando la rapidez de búsqueda justifica su coste, normalmente en estructuras pequeñas y de función específica.

2.9. Memorias secundarias

2.9.1. Características generales

La memoria principal tiene dos limitaciones: poca capacidad comparada con lo que se necesita y volatilidad (es DRAM). La memoria secundaria es el conjunto de dispositivos no volátiles que conservan programas y datos durante periodos prolongados.

No se accede a ella con instrucciones ordinarias de memoria: los datos se transfieren a la memoria principal mediante operaciones de E/S.

(La introducción de la sección menciona también la organización RAID, que combina varias unidades para mejorar el rendimiento y, en algunas configuraciones, añadir redundancia; no se desarrolla en estos apuntes.)

2.9.2. Discos duros magnéticos (HDD)

Almacenan información magnetizando regiones de uno o varios discos giratorios. Gran capacidad y bajo coste por bit; acceso directo sin recorrer todo; pero, por las piezas mecánicas, tiempos mucho mayores que un SSD. El primero fue el IBM 350 (sistema IBM 305 RAMAC, 1956): 50 discos de unas 24 pulgadas y unos 5 millones de caracteres.

Estructura física:

        Eje de giro
            |
   Cabezal  |     ====== Plato (superficie superior)
   -------->|     ====== (superficie inferior)
   Brazo    |
   -------->|     ====== Plato
            |     ======
   Los brazos se mueven juntos -> todos los cabezales a la misma distancia del eje

Organización de la información:

Técnicas de organización:

Discos antiguos: mismo nº de sectores por pista     ZBR (zonas)
                                                     zona exterior   16 sectores/pista
                                                     zona intermedia 12 sectores/pista
                                                     zona interior    8 sectores/pista

El formateo de bajo nivel (físico) se hace en fábrica y crea la estructura de sectores. Cada sector físico contiene, de forma simplificada:

Los sectores de reserva sustituyen a los defectuosos mediante la reasignación de sectores.

Direccionamiento:

Bloque lógico y sector físico no son lo mismo. Normalmente coinciden en tamaño, pero con la emulación 512e el disco tiene sectores físicos de 4096 B y presenta bloques lógicos de 512 B: 8 bloques lógicos por sector físico. La correspondencia lógico-física no refleja necesariamente cilindros y pistas (por ejemplo, cambia al reasignar sectores).

El controlador funciona gracias al firmware: programas en memoria no volátil que controlan el funcionamiento interno del dispositivo (posicionamiento, errores, traducción de direcciones).

Tiempos de acceso. Para leer hay que mover el cabezal a la pista, esperar a que el sector pase bajo él y transferir:

flowchart LR
    S["Petición"] --> B["Tiempo de búsqueda t_b<br/>mover cabezales a la pista"]
    B --> R["Latencia rotacional t_r<br/>esperar al sector"]
    R --> T["Tiempo de transferencia t_t<br/>leer o escribir los datos"]

Aquí $n$ son las rpm y $f = n/60$ las revoluciones por segundo. La transferencia también se puede expresar con la geometría de la pista:

$v_T = P \cdot f \qquad t_t = \frac{N}{P\,f} = \frac{N_s}{S\,f} = \frac{R}{f} \qquad R = \frac{N}{P} = \frac{N_s}{S}$

donde $P$ son los bytes de datos por pista, $S$ los sectores por pista, $N_s$ los sectores a transferir y $R$ las revoluciones (o fracción) que dura la transferencia. Es un modelo idealizado de transferencia continua dentro de una pista.

$t_a = t_b + t_r \qquad\qquad t_{E/S} = t_b + t_r + t_t = t_a + t_t$

Valores actuales orientativos: 5400 o 7200 rpm, búsquedas de varios ms, transferencias sostenidas de hasta unos 300 MB/s en modelos profesionales. Se conectan por SATA (SATA III: 6 Gb/s, unos 600 MB/s de datos; la interfaz es mucho más rápida que el propio disco) o, en servidores, por SAS (Serial Attached SCSI).

Acceso secuencial frente a aleatorio en un HDD. Son patrones de uso, no el "método de acceso" de 2.3.3 (el HDD sigue siendo de acceso directo):

2.9.3. Unidades de estado sólido (SSD)

Almacenamiento secundario no volátil sin piezas mecánicas, normalmente con flash NAND (presentada por Toshiba en 1987). Ventajas: tiempos de acceso menores (sobre todo en acceso aleatorio), sin ruido ni vibraciones y más resistencia a golpes.

Estructura física:

Formatos: 2.5 pulgadas (normalmente SATA) y M.2 (ranura en la placa). M.2 es un formato y un conector, no determina si la unidad es SATA o PCIe.

Organización de la información:

No confundir las páginas flash con las páginas de la memoria virtual (Tema 6), ni los bloques lógicos con los bloques físicos: una página de 8 KiB puede contener dos bloques lógicos de 4 KiB, y un bloque físico de 256 páginas de 8 KiB son 2 MiB.

La traducción de LBA a ubicación física (chip, bloque, página) la hace la FTL (Flash Translation Layer), en el firmware del controlador. LBA consecutivos no tienen por qué estar en posiciones físicas consecutivas, y la correspondencia cambia durante el funcionamiento.

Bloques lógicos          FTL                 Memoria flash NAND
  LBA 0  ---------->  traducción  ------>  Bloque físico B, página 2
  LBA 1  ---------->     de       ------>  Bloque físico A, página 0
  LBA 2  ---------->  direcciones ------>  Bloque físico B, página 0