Datatoy Logo

Cache disque

Rejouer une étape coûteuse sans recalculer

.cached_task(fn, cache_dir=...) calcule fn(x) et sérialise le résultat en .pkl sous une clé SHA-256 dérivée de l'input et de la fonction. Au prochain run, si la clé existe, le résultat est lu depuis le disque — la fonction n'est jamais appelée.

Signature

Pipeline.cached_task(task, cache_dir: str, count=1) -> Pipeline[CacheEnvelope[OutPacket]]
Pipeline.uncache() -> Pipeline[OutPacket]
python
import tempfile
import time
from olympipe import Pipeline

def expensive_transform(x: int) -> dict:
    time.sleep(0.5)    # simulation calcul lourd
    return {"value": x ** 3, "meta": compute_stats(x)}

with tempfile.TemporaryDirectory() as cache_dir:
    # 1er run : calcule et persiste sur disque
    results = (
        Pipeline(range(1000))
        .cached_task(expensive_transform, cache_dir=cache_dir)
        .uncache()
        .wait_for_result()
    )
    # ~500s

    # 2ème run : lecture disque uniquement
    results_again = (
        Pipeline(range(1000))
        .cached_task(expensive_transform, cache_dir=cache_dir)
        .uncache()
        .wait_for_result()
    )
    # < 2s

⚡ Performance

1 000 items, calcul 0.5s/item

Premier run 8.3min
Deuxième run (cache) 1.8s
🚀 277.8× plus rapide

Comment ça fonctionne

La clé est le SHA-256 de (hash de l'input sérialisé avec cloudpickle + hash de la fonction sérialisée). Les fichiers sont stockés dans cache_dir/<step_hash[:16]>/<key>.pkl, où step_hash est le SHA-256 de la fonction sérialisée. Compatible avec les pipelines à plusieurs étapes : chaque étape a son propre sous-dossier de cache.

Paralléliser une étape mise en cache

Signature : .cached_task(task, cache_dir, count=1). Comme .task, count lance plusieurs workers ; ils partagent le même dossier de cache. Terminez par .uncache() pour récupérer les valeurs brutes.

python
import tempfile
import time
from olympipe import Pipeline

def slow_square(x: int) -> int:
    time.sleep(0.2)
    return x * x

with tempfile.TemporaryDirectory() as cache_dir:
    for run in (1, 2):
        start = time.time()
        res = (
            Pipeline(range(20))
            .cached_task(slow_square, cache_dir=cache_dir, count=4)   # 4 workers
            .uncache()
            .wait_for_result()
        )
        print(f"run {run}: {sorted(res)[:5]}... in {time.time() - start:.1f}s")
Sortie
run 1: [0, 1, 4, 9, 16]... in 1.4s
run 2: [0, 1, 4, 9, 16]... in 0.4s

Exemples liés