Saltearse al contenido

Cachés e invalidación

Una caché cambia tiempo por memoria y corrección. Lo primero es fácil de medir; lo tercero es lo que se olvida. Este capítulo mide el precio de un acierto, calcula cuánto ocupa, y sobre todo ordena las tres formas de invalidar que no producen datos obsoletos.

Cachear es recordar; el problema no es recordar, es saber cuándo olvidar.

`lru_cache` con 100 000 entradas
Métrica Valor
Acierto de caché 50 ns
Memoria por entrada 107 B
100 000 entradas 10.2 MiB (10,7 MB decimales)

python mediciones/05-05-07-optimizar-numpy-cache.py

Cincuenta nanosegundos es el coste de hashear los argumentos y buscar. Comparado con cualquier cálculo real (una consulta, un parseo, una lectura de disco), es gratis.

Los 107 bytes por entrada son lo que hay que vigilar: una caché de un millón de entradas ocupa 100 MB. maxsize no es un detalle, es la frontera entre una optimización y una fuga de memoria (capítulo 02).

1. Por evento. Cuando el dato cambia, se limpia:

from functools import lru_cache
@lru_cache(maxsize=1000)
def tarifas(pais): ...
def al_cambiar_tarifas():
tarifas.cache_clear()

Funciona si el cambio es un evento conocido en el proceso. Falla si el cambio ocurre en otra instancia o en la base de datos.

2. Por versión en la clave. El número de versión forma parte de los argumentos:

def precio(pais, version_tarifas): ...

Cuando cambias las tarifas, subes la versión y las entradas viejas dejan de encontrarse. Es la estrategia más robusta: no requiere coordinación y la caché se autolimpia.

3. Por tiempo (TTL). Aceptas que el dato puede estar obsoleto un rato acotado:

from cachetools import TTLCache
cache = TTLCache(maxsize=1000, ttl=300)

functools no trae TTL; cachetools sí. Se elige cuando el dato cambia sin avisar y un retraso de minutos es aceptable.

El dato cambia… Estrategia
Sólo cuando tu proceso lo cambia Evento (cache_clear)
En otro sitio, con un identificador conocido Versión en la clave
Sin avisar y con tolerancia TTL
Nunca (constante calculada) Sin invalidación
  • Si la función es barata. 50 ns de acierto frente a 200 ns de cálculo no compensan la memoria ni la complejidad.
  • Si el resultado debe ser siempre actual. Precios, saldos, stock: cachear es una decisión de negocio, no técnica.
  • Si el dominio de entrada es enorme y la tasa de acierto baja. Una caché que falla el 90 % de las veces es un diccionario que crece.
  • Si el dato es sensible. Una caché en memoria no está cifrada ni aislada entre usuarios.

Un endpoint tarda 800 ms porque consulta un catálogo que cambia una vez al día. Diseña la caché: qué estrategia, qué tamaño, qué pasa con varios procesos y cómo se invalida a medianoche.

Solución

Estrategia por versión en la clave, con el identificador de la versión del catálogo (una fecha o un número que se incrementa al publicarlo):

from functools import lru_cache
def cargar_catalogo(version):
return {"version": version, "productos": ["a", "b"]}
@lru_cache(maxsize=8)
def catalogo(version):
return cargar_catalogo(version)
  • Tamaño: 8, porque sólo hay una versión vigente y quizá la anterior durante el despliegue. Con maxsize=8 la memoria es constante.
  • Varios procesos: cada worker tiene su caché, pero todos piden la misma versión. Al publicar la nueva, todos empiezan a pedir la nueva clave y la vieja se descarta por LRU. No hace falta coordinación.
  • Medianoche: no hace falta invalidar nada; cambia la versión y la clave cambia.

La alternativa con TTL de 24 horas es más simple y tiene un fallo incómodo: la primera petición después de la expiración paga los 800 ms otra vez, en el momento menos oportuno. Con versión, ese coste ocurre una vez por proceso y en el momento de la publicación, que se puede controlar.

  • Ramalho, L. Fluent Python, 2ª ed. Capítulo 9: functools.cache.
  • Lott, S. F. Modern Python Cookbook, 3ª ed. Capítulo 6.
  • Mediciones: mediciones/05-05-07-optimizar-numpy-cache.py.
  • 02 · Fugas: la caché sin límite como fuga clásica.
  • 04 · functools (Parte III): lru_cache en detalle.
  • 05 · Optimizar: cuándo la caché es la respuesta y cuándo es una distracción.