RAM: SRAM y DRAM

01 · Punto de partida

Qué es la RAM y por qué hay dos

RAM significa Random Access Memory, memoria de acceso aleatorio: se puede leer o escribir cualquier palabra, en cualquier orden, en el mismo tiempo (a diferencia de una cinta o un disco, donde el orden importa). La organización es la del tema anterior: direcciones, palabras y tres señales de control. Lo que cambia es la celda que guarda cada bit.

Hay una tensión de diseño inevitable: una celda que se sostiene a sí misma es rápida pero grande; una celda mínima es chica pero hay que cuidarla.

02 · SRAM

SRAM: la celda de seis transistores

La celda de una SRAM es un biestable: dos inversores realimentados cuyos estados estables son «Q = 1, Q̅ = 0» y «Q = 0, Q̅ = 1». Es el mismo principio de los latches del tema 4: mientras haya alimentación, la realimentación regenera la señal y el bit se sostiene solo. Cada inversor CMOS lleva dos transistores, así que el biestable ocupa cuatro; otros dos transistores de acceso conectan la celda a las líneas de bit cuando se activa la línea de palabra (WL).

Cómo se usa:

• Reposo (WL = 0): los transistores de acceso están cortados, la celda queda aislada y se sostiene sola. Las líneas de bit pueden cambiar sin que la celda se entere.
• Lectura: se activa WL; la celda empuja BL y BL̅ hacia sus valores, y un amplificador diferencial detecta cuál de las dos es mayor. La lectura no destruye el dato.
• Escritura: se activa WL y se fuerzan BL y BL̅ a valores opuestos; los controladores de escritura, más fuertes que los inversores de la celda, la hacen cambiar de estado.

La SRAM tiene tres virtudes claras: es rápida (no hay nada que esperar para recuperar el dato), sencilla de usar (los chips como el 6116 o el 62256 se conectan como en el tema 26, sin refresco) y de consumo mínimo en reposo (en CMOS, con CS̅ inactivo la corriente es de microamperes; con una pila pequeña mantiene sus datos años). Su límite es el área: seis transistores por bit.

03 · DRAM

DRAM: un transistor y un condensador

La celda de una DRAM es la más pequeña posible: un condensador que guarda el bit como carga (cargado = 1, descargado = 0) y un transistor que lo conecta a la línea de bit cuando se activa la línea de palabra. Con un solo transistor por bit, la densidad es muy superior; por eso la memoria principal de casi todos los equipos es DRAM.

El costo de esta simplicidad se paga en tres frentes:

1. Fuga: el condensador es diminuto (decenas de femtofaradios) y el transistor, aun cortado, deja escapar una corriente minúscula. La carga disminuye y en pocas decenas de milisegundos deja de distinguirse de un cero. Hay que refrescar.
2. Lectura destructiva: al activar WL, la carga del condensador se reparte con la línea de bit, que es mucho mayor. El cambio de tensión es de apenas decenas de milivoltios y la celda queda casi descargada. Un amplificador de sensado detecta si la tensión subió o bajó respecto de una referencia, la amplifica y reescribe el valor leído en la celda. Toda lectura es también un refresco.
3. Direccionamiento por filas y columnas: para ahorrar pines, las DRAM reciben la dirección en dos mitades por los mismos pines (tema 26): primero la de fila, con la señal RAS̅ (row address strobe), y después la de columna, con CAS̅. Al activar una fila, se leen y se restauran de golpe todas las celdas de esa fila; después se elige la columna que interesa.

04 · Refresco

El refresco

Si un uno pierde la mitad de su carga, el amplificador de sensado ya no puede distinguirlo de un cero. El tiempo máximo antes de que eso ocurra, en el peor caso, se llama tiempo de retención. Las DRAM modernas especifican 64 ms a temperatura normal: todas las filas tienen que leerse y reescribirse dentro de esa ventana. Como la lectura restaura la fila, refrescar es simplemente abrir y cerrar cada fila antes de que se agote el plazo.

El refresco usa poco tiempo, pero no es gratis: durante cada refresco de fila el chip no atiende accesos, y consume energía incluso cuando nadie lo usa. Además, la fuga crece con la temperatura: aproximadamente se duplica cada 10 °C, de modo que a 85 °C la ventana es de unos 4 ms en el modelo simplificado y el intervalo entre filas se reduce a una fracción de microsegundo. Por eso las memorias para ambientes calientes tienen modos de refresco extendido.

Cómo se refresca

• Solo RAS (RAS-only): el controlador entrega las direcciones de fila una por una. Es el método clásico, que requiere un contador de filas externo.
• Autorrefresco (CBR / auto-refresh): el chip lleva su propio contador de filas; el controlador solo emite la orden de refresco.
• Autorrefresco en espera (self-refresh): con el sistema en reposo, el chip se refresca solo con su reloj interno; es lo que mantiene los datos cuando una computadora «duerme» a bajo consumo.

En las memorias que ves en una computadora (SDRAM, DDR), el controlador de memoria se encarga de todo esto: coordina los refrescos con los accesos del procesador para que el programa ni se entere.

05 · Volatilidad

Volatilidad

Una memoria es volátil si pierde su contenido cuando se le quita la alimentación. Tanto la SRAM como la DRAM lo son, pero por razones distintas:

• SRAM: el biestable necesita Vcc para sostener sus dos inversores. Al cortarla, los nodos se descargan en microsegundos y, al volver la energía, cada celda cae en un estado al azar (el que favorezca una pequeña asimetría física).
• DRAM: sin Vcc, además, no hay refresco: los condensadores se descargan por fuga en milisegundos o, enfriada, en segundos o minutos (por eso se ha logrado recuperar datos de módulos enfriados un instante después de apagar el equipo).

Una consecuencia práctica: al encender, el contenido de una RAM es indefinido. Un programa que lea una variable sin haberla escrito obtiene basura, igual que un flip-flop sin reset. Por eso el arranque de un sistema incluye un código que inicializa la memoria (y por eso las variables globales en C se ponen a cero al iniciar).

Cuando se necesita una RAM que no pierda datos, se recurre a: una SRAM de bajo consumo con una pila o supercondensador de respaldo; una memoria no volátil como la EEPROM o la Flash (temas 29 y 30), más lenta y con desgaste; o tecnologías mixtas como FRAM o MRAM, de acceso rápido y sin volatilidad, aunque más caras y menos densas.

06 · Tiempos

Tiempos de acceso

En una SRAM, el acceso es un solo paso: se pone la dirección, se espera t_AA y el dato aparece (tema 26). En una DRAM, el acceso tiene varias etapas y su duración depende del estado en que esté el chip:

Así, la latencia depende de la situación. Con una DDR3-1600 típica (reloj de 800 MHz, ciclo de 1,25 ns, y t_RCD = CL = t_RP = 11 ciclos):

Latencia no es lo mismo que ancho de banda

La latencia es cuánto se tarda en recibir el primer dato. El ancho de banda es cuántos datos llegan por segundo cuando el flujo ya está en marcha. Una DRAM síncrona sufre al empezar, pero con una fila abierta puede entregar una ráfaga de columnas consecutivas a gran velocidad: en una DDR3-1600 con bus de 64 bits, 12,8 GB/s. La consecuencia para el software es que conviene acceder a la memoria de forma secuencial y por bloques; el procesador, por eso, trae datos a su caché de a líneas de 64 bytes y no de a uno.

07 · Comparación

SRAM frente a DRAM

En un sistema real conviven ambas, en una jerarquía de memoria: poca SRAM muy rápida junto al procesador (cachés), mucha DRAM más lenta como memoria principal y, más abajo, almacenamiento no volátil. Los microcontroladores sencillos tienen SRAM interna (de 512 bytes a cientos de KiB) y no necesitan DRAM; los procesadores de aplicaciones, que ejecutan sistemas operativos completos, necesitan los gigabytes que solo la DRAM ofrece a un precio razonable.

08 · Las celdas en código

Biestables, condensadores y refresco

Los bloques modelan la celda de SRAM con sus accesos, simulan la descarga de una celda de DRAM y la supervivencia de un bit con distintos períodos de refresco, calculan el costo del refresco y comparan transistores y latencias.

Paso 1: la celda de SRAM y un banco de 4 × 4

class CeldaSRAM:
    """Celda de 6 transistores: dos inversores cruzados guardan el bit; dos transistores de acceso lo conectan a las líneas de bit."""

    def __init__(self):
        self.q = 0                                    # nodo Q (el nodo Q̅ vale 1 - q)

    def acceso(self, wl, bl=None, bl_n=None):
        if not wl:                                    # línea de palabra en 0: la celda está aislada y RETIENE
            return None
        if bl is not None and bl_n is not None and bl != bl_n:
            self.q = bl                               # escritura: las líneas de bit (fuertes) vencen a los inversores
            return None
        return self.q                                 # lectura: la celda empuja las líneas de bit hacia su valor


celda = CeldaSRAM()
print("escribo 1: acceso(wl=1, bl=1, bl_n=0)")
celda.acceso(1, 1, 0)
print("  q =", celda.q)
print("las líneas de bit se mueven con wl = 0 (la celda no se entera):")
for bl, bl_n in ((0, 1), (1, 0), (0, 1)):
    celda.acceso(0, bl, bl_n)
    print(f"  bl={bl} bl_n={bl_n} -> q sigue en {celda.q}")
print("leo con wl = 1:", celda.acceso(1))
print("la lectura no la destruye:", celda.acceso(1), celda.acceso(1))

# Un banco de 4 palabras de 4 bits: la línea de palabra elige la fila
banco = [[CeldaSRAM() for _ in range(4)] for _ in range(4)]


def escribir(dir_, valor):
    for i, c in enumerate(banco[dir_]):
        b = (valor >> (3 - i)) & 1
        c.acceso(1, b, 1 - b)


def leer(dir_):
    return sum(c.acceso(1) << (3 - i) for i, c in enumerate(banco[dir_]))


for d, v in enumerate((0b1010, 0b0110, 0b1111, 0b0001)):
    escribir(d, v)
print()
print("banco 4 x 4 leído:", *(f"{leer(d):04b}" for d in range(4)))
print("transistores: 6 por celda ->", 6 * 16, "para las 16 celdas")

La escritura fuerza Q a 1; mientras WL vale 0, las líneas de bit pueden oscilar y la celda sigue en 1. La lectura devuelve 1 sin alterar nada, las veces que se repita: es no destructiva. El banco de 4 × 4 guarda y devuelve las cuatro palabras (1010, 0110, 1111, 0001) y consume 96 transistores solo en celdas.

Paso 2: la fuga de la DRAM y el refresco

from math import exp, log

T_RET = 64.0                                  # ms: tiempo en que un 1 baja de 100 % a 50 % de la carga
TAU = T_RET / log(2)                          # constante de tiempo de la fuga
print(f"retención {T_RET:.0f} ms -> tau = {TAU:.1f} ms")
print("carga restante de una celda con un '1' sin refrescar:")
for t in (0, 16, 32, 64, 96, 128, 256):
    v = exp(-t / TAU)
    print(f"  t = {t:3d} ms: {v * 100:5.1f} %  -> se lee {'1' if v > 0.5 else '0 (ERROR)'}")


def sobrevive(periodo_refresco, total_ms=1000):
    """Un '1' con refresco cada 'periodo_refresco' ms: ¿sigue siendo un 1 al final?"""
    v, t = 1.0, 0
    while t + periodo_refresco <= total_ms:
        v *= exp(-periodo_refresco / TAU)           # durante el período la celda se descarga
        t += periodo_refresco
        if v > 0.5:
            v = 1.0                                 # el amplificador de sensado lee 1 y recarga la celda
        else:
            return False                            # se leyó 0: el dato ya se perdió
    return v * exp(-(total_ms - t) / TAU) > 0.5


print()
for p in (16, 32, 60, 64, 70, 100):
    print(f"refresco cada {p:3d} ms durante 1 s: {'el dato sobrevive' if sobrevive(p) else 'SE PIERDE'}")

# la lectura es destructiva: hay que reescribir
print()
v = 0.8
print(f"celda con {v * 100:.0f} % de carga: la lectura la descarga al compartir carga con la línea de bit")
print("el amplificador de sensado detecta si quedó por encima o por debajo del medio y la reescribe:")
v = 1.0 if v > 0.5 else 0.0
print(f"  tras leer y reescribir: {v * 100:.0f} %")

Con una retención de 64 ms (τ ≈ 92,3 ms), un uno conserva el 84 % a los 16 ms y el 71 % a los 32 ms; a los 64 ms está justo en el 50 % y se lee como cero. Con refresco cada 16, 32 o 60 ms el dato sobrevive un segundo entero; con 64 ms (el límite exacto) o más, se pierde. El margen de diseño es el espacio entre el período de refresco y la retención: por eso se refresca bastante antes del límite. La última parte muestra la lectura destructiva con restauración.

Paso 3: cuánto cuesta el refresco

ventana_ms = 64.0                             # todo el contenido debe refrescarse dentro de esta ventana
print("filas   intervalo entre refrescos de fila   tiempo de cada refresco   ocupación")
for filas, t_fila_ns in ((4096, 70), (8192, 50), (16384, 50), (65536, 45)):
    intervalo_us = ventana_ms * 1000 / filas
    ocupacion = filas * t_fila_ns * 1e-9 / (ventana_ms * 1e-3)
    print(f"{filas:6d}   {intervalo_us:8.2f} us ({1e3 / intervalo_us:6.1f} kHz)         {t_fila_ns:3d} ns               {ocupacion * 100:5.2f} %")

print()
print("el calor acorta la retención (aprox. mitad cada +10 °C):")
for temp in (45, 55, 65, 75, 85):
    ventana = 64.0 / 2 ** ((temp - 45) / 10)
    intervalo = ventana * 1000 / 8192
    print(f"  {temp} °C: ventana {ventana:5.1f} ms -> una fila cada {intervalo:5.2f} us")

Con 8192 filas y una ventana de 64 ms, hay que refrescar una fila cada 7,81 µs (128 000 refrescos por segundo), que ocupan el 0,64 % del tiempo. Con más filas, el intervalo se acorta y la ocupación sube: 4,6 % con 65 536 filas. El calor empeora todo: en el modelo simplificado, de 45 a 85 °C la ventana pasa de 64 a 4 ms y el intervalo entre filas, de 7,81 µs a 0,49 µs.

Paso 4: transistores, latencias y ancho de banda

bits = 1024 * 1024                            # 1 Mbit
sram_t = 6 * bits
dram_t = 1 * bits                             # un transistor por bit (más un condensador)
print(f"1 Mbit: SRAM {sram_t:,} transistores | DRAM {dram_t:,} transistores + {bits:,} condensadores")
print(f"relación de transistores: {sram_t / dram_t:.0f} a 1; en área, la celda DRAM es varias veces menor")
print()

# Latencia de acceso de una DRAM síncrona (valores ilustrativos de una DDR3-1600)
ciclo_ns = 1.25                               # reloj de 800 MHz
tRCD, CL, tRP = 11, 11, 11                    # en ciclos
print(f"reloj {1000 / ciclo_ns:.0f} MHz, ciclo {ciclo_ns} ns; tRCD = CL = tRP = {tRCD} ciclos")
acierto = CL * ciclo_ns
fallo_cerrada = (tRCD + CL) * ciclo_ns
fallo_otra_fila = (tRP + tRCD + CL) * ciclo_ns
print(f"  fila ya abierta (acierto):           {acierto:5.2f} ns")
print(f"  banco cerrado (activar y leer):       {fallo_cerrada:5.2f} ns")
print(f"  otra fila abierta (cerrar, activar):  {fallo_otra_fila:5.2f} ns")
print()
sram_ns = 10
print(f"una SRAM rápida accede siempre en ~{sram_ns} ns (no hay filas que abrir)")
print(f"relación en el peor caso: la DRAM tarda {fallo_otra_fila / sram_ns:.1f} veces más que la SRAM")

# ancho de banda en ráfaga: el acceso a columnas siguientes de la misma fila es rápido
rafaga = 8
bytes_por_beat = 8                            # bus de 64 bits
ancho = 2 * 800e6 * bytes_por_beat / 1e9      # DDR: dos transferencias por ciclo
print(f"\nancho de banda máximo en ráfaga (DDR3-1600, bus de 64 bits): {ancho:.1f} GB/s")
print(f"una ráfaga de {rafaga} transferencias entrega {rafaga * bytes_por_beat} bytes tras la latencia inicial")

Un megabit de SRAM necesita 6,3 millones de transistores; el de DRAM, 1 millón (más un condensador por bit). En latencia, con una DDR3-1600 un acierto de fila tarda 13,75 ns, un banco cerrado 27,5 ns y un cambio de fila 41,25 ns, unas 4 veces lo de una SRAM rápida (≈ 10 ns). Pero el ancho de banda en ráfaga llega a 12,8 GB/s: la DRAM pierde en latencia y gana en volumen y en flujo sostenido.

Los cuatro bloques cuentan la misma historia: la SRAM es simple y rápida pero grande; la DRAM es pequeña y barata pero exige refresco, un controlador y paciencia para el primer dato.

09 · Exploración interactiva

El laboratorio: celdas que se olvidan

El simulador tiene ocho celdas que representan un byte, en SRAM o en DRAM. Escribís un patrón de bits, hacés pasar el tiempo y mirás qué pasa con cada celda. En la DRAM cada barra es la carga del condensador, que baja con el tiempo de retención que elijas; una línea punteada marca el 50 %, el umbral de lectura. Con el refresco automático activado, todas las celdas se leen y se reescriben cada cierto período. También podés cortar la alimentación para ver qué pasa en cada tecnología.

Recorrido guiado

1. Con DRAM, retención de 64 ms y sin refresco, escribí 10110101 y presioná «Esperar 10 ms» varias veces: las barras de los unos bajan (90 %, 81 %, 72 %…). A los 60 ms siguen justo por encima del 50 %.
2. Pasá los 64 ms: los unos cruzan el umbral, se leen como cero y aparecen los errores (borde naranja). Presioná «Leer todo»: la lectura reescribe lo que leyó, y el error queda permanente.
3. Escribí de nuevo, activá el refresco automático cada 32 ms y esperá 100 ms diez veces: ningún error. Mirá «Refrescos realizados» subir: el refresco restituye la carga antes de cruzar el umbral.
4. Subí el período de refresco a 100 ms (más largo que la retención) y repetí: los datos se pierden aunque el refresco esté activado. El período debe ser menor que la retención, con margen.
5. Bajá la retención a 16 ms (como si se calentara el chip) con el refresco cada 32 ms: ahora falla. Hay que acortar el período a 8 ms o menos.
6. Cambiá a SRAM: escribí, esperá 100 ms varias veces: nada cambia, el refresco no hace falta y los controles de retención no tienen efecto.
7. Con cualquiera de las dos, presioná «Cortar alimentación»: todas las celdas pasan a «?» y el patrón se pierde. Con «Restaurar alimentación» arrancan al azar.
8. Comparalas: la SRAM no se olvida mientras haya energía y la DRAM sí, aunque la tenga; la diferencia es que la DRAM, con refresco, ocupa mucho menos silicio.

10 · Comprensión

Confusiones frecuentes

11 · Práctica guiada

Predecí antes de simular

1. Transistores

Una memoria tiene 8 Mbit. ¿Cuántos transistores tienen solo las celdas si es SRAM de 6T? ¿Y si es DRAM de 1T1C?

2. Intervalo de refresco

Una DRAM con 16 384 filas debe refrescarse dentro de 64 ms. ¿Cada cuánto hay que refrescar una fila? Si cada refresco de fila ocupa 50 ns, ¿qué fracción del tiempo ocupa el refresco?

3. Temperatura

Si la retención cae a la mitad cada 10 °C a partir de 64 ms a 45 °C, ¿cuál es la ventana a 75 °C y el intervalo por fila con 8192 filas?

4. Carga restante

Una celda con retención de 64 ms tiene un 1 al 100 %. ¿Qué carga le queda a los 96 ms sin refrescar y qué se lee?

5. Latencias

Una DRAM con ciclo de 1,25 ns tiene t_RCD = CL = t_RP = 9 ciclos. ¿Cuánto tarda un acierto de fila, un acceso a banco cerrado y un cambio de fila?

6. Diagnóstico

Un equipo con DRAM presenta bits erróneos esporádicos en zonas de memoria poco usadas, y se nota más cuando el equipo está caliente. Las zonas muy usadas están bien. ¿Qué puede estar pasando?

12 · Síntesis

Ideas para recordar

¿Listo para el tema 28?

Antes de avanzar, explicá de memoria cómo guarda un bit cada tipo de RAM, por qué la DRAM necesita refresco y qué significa que una memoria sea volátil. Si podés justificar las tres respuestas, ya podés pasar a las memorias que conservan su contenido sin energía.

En el próximo tema veremos la ROM y las tablas de consulta: memorias de solo lectura (de máscara, PROM y EPROM) y cómo una memoria puede guardar no solo datos sino también lógica combinacional.