letify 2.4.2__tar.gz → 2.4.4__tar.gz

{letify-2.4.2 → letify-2.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: letify
-Version: 2.4.2
+Version: 2.4.4
 Summary: Declarations that become infrastructure.
 Project-URL: Homepage, https://github.com/DarkPyonix/letify
 Project-URL: Documentation, https://github.com/DarkPyonix/letify/tree/main/docs

{letify-2.4.2 → letify-2.4.4}/letify/__init__.py

@@ -33,6 +33,7 @@ from .declare.cache import session_cache
 from .declare.env import Env
 from .declare.function import Function
 from .declare.instance import AnyInstance, Host, Instance
+from .declare.replicas import local_steps, rank, world_size
 from .errors import (
     ConfigError,
     EnvironmentFailure,
@@ -58,11 +59,12 @@ from .store.volume import Volume
 #: ``Final`` so a type checker sees the literal member, which the declaration overloads match on.
 local: Final = Host.local
 remote: Final = Host.remote
+distributed: Final = Host.distributed
 
 # The enum class stays importable from letify.declare.instance for letify's own use.
 del Host
 
-__version__ = "2.4.2"
+__version__ = "2.4.4"
 
 
 def fetch(tensor):  # type: ignore[no-untyped-def]
@@ -101,7 +103,11 @@ __all__ = [
     "UnsupportedMode",
     "Volume",
     "__version__",
+    "distributed",
     "local",
+    "local_steps",
+    "rank",
     "remote",
     "session_cache",
+    "world_size",
 ]

{letify-2.4.2 → letify-2.4.4}/letify/declare/function.py

@@ -65,7 +65,9 @@ class Function(Generic[R]):
         self.data_order = data_order
         self.data_first_wave = data_first_wave
         self.is_async = inspect.iscoroutinefunction(fn)
-        self.device = self._place(device)
+        #: Spec "Replicas": one Instance per replica, in the order the list named them.
+        self.replicas = _replicas(device, self.host)
+        self.device = self._place(self.replicas[0] if self.replicas else device)
         update_wrapper(self, fn)
 
     def _place(self, device: Instance | AnyInstance) -> Instance | AnyInstance:
@@ -136,6 +138,16 @@ class Function(Generic[R]):
 
     def _run(self, args: tuple, kwargs: dict) -> Any:
         launcher = self.launcher
+        if self.host is Host.distributed:
+            # Spec "Replicas": the placement is declared and the runner is not written
+            # yet. Running the first replica alone would bill one runtime for a
+            # declaration that asked for several, without saying so.
+            raise UnsupportedMode(
+                f"host=letify.distributed declares {len(self.replicas)} replicas and "
+                f"letify cannot run them yet, so the call is refused rather than run on "
+                f"one of them. Use host=letify.remote with a single device until it is "
+                f"finished."
+            )
         instance = launcher.resolve(self.device)
         if instance.placement is Host.local:
             return self._run_here(instance, args, kwargs)
@@ -249,6 +261,42 @@ def _report_deferred(delta: Any) -> None:
         )
 
 
+def _replicas(device: Any, host: Host) -> tuple[Instance, ...]:
+    """The replicas a declaration names, or empty when it names a single device.
+
+    Spec "Replicas": ``device`` takes a list only under ``host=letify.distributed``, each
+    entry is one replica, and two replicas of one instance are refused because that asks
+    one account for twice the devices it has.
+    """
+    listed = isinstance(device, (list, tuple))
+    if listed and host is not Host.distributed:
+        raise ValueError(
+            f"device is a list of {len(device)} instances, which declares one replica "
+            f"each, so it needs host=letify.distributed. Under host={host.value!r} name "
+            f"one device."
+        )
+    if not listed:
+        return (device,) if host is Host.distributed else ()
+    if not device:
+        raise ValueError(
+            "device is an empty list, so the declaration names no replica. Name at least "
+            "one instance."
+        )
+    seen: list[str] = []
+    for instance in device:
+        alias = getattr(getattr(instance, "provider", None), "alias", None)
+        name = getattr(instance, "accelerator", None)
+        key = f"{alias}.{name}"
+        if key in seen:
+            raise ValueError(
+                f"device names {key} twice, so one account would be asked for twice the "
+                f"devices one replica takes. Name each account once, and use a larger "
+                f"instance such as {name} * 2 for more devices in one replica."
+            )
+        seen.append(key)
+    return tuple(device)
+
+
 def _where(host: Host | str | None) -> Host:
     """Validate the declared host placement, naming both options when it is wrong."""
     if host is None:
@@ -258,8 +306,9 @@ def _where(host: Host | str | None) -> Host:
     except ValueError:
         raise ValueError(
             f"host={host!r} is not a host placement. Use host='local' to keep Python "
-            f"here and forward PyTorch operators, or host='remote' to ship the function to "
-            f"the machine that holds the device."
+            f"here and forward PyTorch operators, host='remote' to ship the function to "
+            f"the machine that holds the device, or host='distributed' to run it once per "
+            f"device in a list."
         ) from None
 
 

{letify-2.4.2 → letify-2.4.4}/letify/declare/instance.py

@@ -39,6 +39,9 @@ class Host(StrEnum):
 
     local = "local"
     remote = "remote"
+    #: The same body on every device of a ``device`` list, each replica knowing its rank.
+    #: Spec "Replicas".
+    distributed = "distributed"
 
 
 @dataclass(frozen=True, slots=True)

letify-2.4.4/letify/declare/replicas.py

@@ -0,0 +1,111 @@
+"""Where a replica learns which one it is, and what it reduces with.
+
+Owns the per-replica facts a distributed body reads, ``rank`` and ``world_size``, and the
+reduction a body asks for. It does not own the loop; spec "Replicas" says so and
+``docs/INTENT.md`` keeps that as a non-goal for every loop but one.
+"""
+
+from __future__ import annotations
+
+import math
+import threading
+from typing import Any
+
+from ..errors import UnsupportedMode
+
+#: Set on the thread running a distributed body, so ``rank`` and ``world_size`` answer.
+_WHO = threading.local()
+
+_OUTSIDE = (
+    "{name}() answers only inside a call declared with host=letify.distributed. A body "
+    "under host=letify.remote has one replica and no rank, and answering 0 and 1 here "
+    "would hide that it was asked"
+)
+
+
+def rank() -> int:
+    """Which replica this is, 0 upward in the order the ``device`` list names.
+
+    Spec "Replicas": raises outside a distributed call rather than answering 0.
+    """
+    found = getattr(_WHO, "rank", None)
+    if found is None:
+        raise UnsupportedMode(_OUTSIDE.format(name="rank"))
+    return int(found)
+
+
+def world_size() -> int:
+    """How many replicas started. Spec "Replicas"."""
+    found = getattr(_WHO, "world_size", None)
+    if found is None:
+        raise UnsupportedMode(_OUTSIDE.format(name="world_size"))
+    return int(found)
+
+
+#: The fraction of a step a reduction may take before it is worth doing less often.
+DEFAULT_SHARE = 0.25
+
+
+def steps_for(
+    *,
+    param_bytes: int,
+    step_seconds: float,
+    rate_bps: float | None,
+    share: float = DEFAULT_SHARE,
+) -> int:
+    """The smallest number of local steps for which a reduction is cheap enough.
+
+    Spec "How often to synchronize": a reduction moves the parameters once, so it is
+    worth it only when rare enough against the step it interrupts. Raises rather than
+    guessing when the link reports no rate, because a guess here is a guess about the
+    whole run's shape.
+    """
+    if not rate_bps or rate_bps <= 0:
+        raise UnsupportedMode(
+            "local_steps needs the link's measured upload rate and this link reports "
+            "none, so there is nothing to divide the parameters by. The rate comes from "
+            "the probe, so a link the pipeline never probed, such as a provider "
+            "fallback, cannot answer. Pass the count instead of letify.auto"
+        )
+    if step_seconds <= 0:
+        raise ValueError("step_seconds has to be above zero to divide a transfer against")
+    allowed = max(share, 0.0) * step_seconds
+    if allowed <= 0:
+        raise ValueError("share has to be above zero, or no number of steps is ever enough")
+    transfer = param_bytes / rate_bps
+    return max(1, math.ceil(transfer / allowed))
+
+
+def local_steps(param_bytes: int, step_seconds: float, share: float = DEFAULT_SHARE) -> int:
+    """How many steps to take between reductions, from the link letify already measured.
+
+    Spec "How often to synchronize". Answers for the replica this body runs on, so two
+    replicas on links of different speed get different answers.
+    """
+    rate = getattr(_WHO, "rate_bps", None)
+    return steps_for(
+        param_bytes=param_bytes,
+        step_seconds=step_seconds,
+        rate_bps=rate,
+        share=share,
+    )
+
+
+class _Replica:
+    """Holds the rank for the body's thread, so nothing has to be passed through it."""
+
+    def __init__(self, rank: int, world_size: int, rate_bps: float | None = None) -> None:
+        self.rank = rank
+        self.world_size = world_size
+        self.rate_bps = rate_bps
+
+    def __enter__(self) -> _Replica:
+        _WHO.rank, _WHO.world_size = self.rank, self.world_size
+        _WHO.rate_bps = self.rate_bps
+        return self
+
+    def __exit__(self, *_exc: Any) -> None:
+        _WHO.rank = _WHO.world_size = _WHO.rate_bps = None
+
+
+__all__ = ["local_steps", "rank", "steps_for", "world_size"]

{letify-2.4.2 → letify-2.4.4}/letify/protocol/worker.py

@@ -365,6 +365,19 @@ def _data_hash_file(path):
     return hasher.hexdigest(length=16)
 
 
+def _data_same_bytes(path, digest):
+    """Whether the file still hashes to the digest it is the blob of.
+
+    Spec "Runtime data cache budget": only the ambiguous case is hashed, a size that
+    matches with a new timestamp, so the read is paid where a timestamp cannot decide.
+    Never raises; a file that cannot be read is not the file the digest promised.
+    """
+    try:
+        return _data_hash_file(path) == digest
+    except OSError:
+        return False
+
+
 def _data_collect(data, placed):
     """Commit each file a returned call created or changed at an output into the cache."""
     import stat
@@ -431,11 +444,25 @@ def _data_check_cache(data, placed):
             info = os.stat(source)
         except OSError:
             continue
-        if (info.st_size, info.st_mtime_ns) != cached:
-            try:
-                os.remove(source)
-            except OSError:
-                pass
+        if (info.st_size, info.st_mtime_ns) == cached:
+            continue
+        if info.st_size == cached[0] and _data_same_bytes(source, digest):
+            # Spec "Runtime data cache budget": the same bytes with a new timestamp, which
+            # is what a file copied back looks like. The digest still holds, so it stays.
+            continue
+        # Spec "Runtime data cache budget": removing a file a call may still need is worth
+        # a line, or it vanishes and only the next failure mentions it.
+        print(
+            "letify: data cache dropped %s, written through its link (%d bytes at %d, "
+            "placed as %d at %d)"
+            % (digest, info.st_size, info.st_mtime_ns, cached[0], cached[1]),
+            file=sys.stderr,
+            flush=True,
+        )
+        try:
+            os.remove(source)
+        except OSError:
+            pass
 
 
 def _op_data_written(request):
@@ -675,12 +702,38 @@ def _data_budget(root, total, budget):
     return min(_DATA_DEFAULT_BUDGET, (total + free) // 2)
 
 
+def _digest_of(path):
+    """The digest a blob path holds, which is its shard directory and its name joined."""
+    return os.path.basename(path)
+
+
+def _data_digests_in_flight():
+    """Every digest a running call lists, so the prune does not take one out from under it.
+
+    Spec "Runtime data cache budget". Read under the lock the data thread writes the maps
+    with, so a call registering while this reads cannot change one mid iteration.
+    """
+    wanted = set()
+    with _DATA_READY:
+        for state in list(_DATA_CALLS.values()):
+            wanted.update(state["by_digest"])
+    return wanted
+
+
 def _op_data_evict(request):
-    """Remove least recently used blobs no call links until the cache is within budget."""
+    """Remove least recently used blobs no call links until the cache is within budget.
+
+    Spec "Runtime data cache budget": a digest a running call lists is skipped whatever
+    its link count and age, because the call was told the runtime held it and so did not
+    send it. ``recent`` is the window a blob no call is using is protected for, carried on
+    the request beside the budget.
+    """
     started = time.monotonic()
     root = os.path.expanduser(request["dir"])
     files, total = _data_scan(root)
     budget = _data_budget(root, total, request.get("budget"))
+    recent = float(request.get("recent", _DATA_RECENT_S))
+    wanted = _data_digests_in_flight()
     removed = freed = 0
     if total > budget:
         now = time.time()
@@ -688,7 +741,7 @@ def _op_data_evict(request):
         for used, path, size, links in files:
             if total <= budget:
                 break
-            if links > 1 or now - used < _DATA_RECENT_S:
+            if links > 1 or now - used < recent or _digest_of(path) in wanted:
                 continue
             try:
                 os.remove(path)

{letify-2.4.2 → letify-2.4.4}/letify/store/pathdata.py

@@ -1183,7 +1183,10 @@ def _get(
     """
     from ..protocol.codec import _hasher
 
-    target.parent.mkdir(parents=True, exist_ok=True)
+    # Spec "Writing back": a stream that fails after these were created would leave them
+    # empty, and a resume that picks the newest directory by name then trusts a checkpoint
+    # holding nothing. Remembered so the failure can take back exactly what it made.
+    made = _made_dirs(target.parent)
     partial = target.with_name(
         f".{target.name}.letify-partial.{os.getpid()}.{threading.get_ident()}"
     )
@@ -1210,6 +1213,7 @@ def _get(
     writer = threading.Thread(target=write_pieces, daemon=True)
     writer.start()
     received = 0
+    landed = False
     try:
         for piece in _stream(runtime, {"op": "data_stream", "dir": blobs, "digest": digest}):
             view = memoryview(piece).cast("B")
@@ -1230,11 +1234,46 @@ def _get(
         if found != digest:
             raise RuntimeFailure(f"{runtime.name}: file blob {digest} arrived with digest {found}")
         os.replace(partial, target)
+        landed = True
     finally:
         if writer.is_alive():
             pieces.put(None)
             writer.join(5)
+        # Before the directories are taken back, or they would not be empty yet.
         partial.unlink(missing_ok=True)
+        if not landed:
+            _unmake_dirs(made)
+
+
+def _made_dirs(directory: Path) -> list[Path]:
+    """Create ``directory`` and return the ones this call had to make, innermost last.
+
+    Spec "Writing back": only what letify made is ever taken back, so a directory the
+    user already had is never touched.
+    """
+    missing: list[Path] = []
+    probe = directory
+    while not probe.exists():
+        missing.append(probe)
+        parent = probe.parent
+        if parent == probe:
+            break
+        probe = parent
+    directory.mkdir(parents=True, exist_ok=True)
+    return list(reversed(missing))
+
+
+def _unmake_dirs(made: list[Path]) -> None:
+    """Remove the directories ``_made_dirs`` created, innermost first, while empty.
+
+    Spec "Writing back". A directory that holds anything is left alone, because something
+    else put it there.
+    """
+    for directory in reversed(made):
+        try:
+            directory.rmdir()
+        except OSError:
+            return
 
 
 def _worker(runtime: Runtime, payload: dict[str, Any]) -> Any:

{letify-2.4.2 → letify-2.4.4}/letify-core/Cargo.lock

@@ -138,7 +138,7 @@ dependencies = [
 
 [[package]]
 name = "letify-agent"
-version = "2.4.2"
+version = "2.4.4"
 dependencies = [
  "letify-wire",
  "libloading",
@@ -146,7 +146,7 @@ dependencies = [
 
 [[package]]
 name = "letify-driver"
-version = "2.4.2"
+version = "2.4.4"
 dependencies = [
  "letify-wire",
 ]
@@ -164,7 +164,7 @@ dependencies = [
 
 [[package]]
 name = "letify-wire"
-version = "2.4.2"
+version = "2.4.4"
 
 [[package]]
 name = "libc"

{letify-2.4.2 → letify-2.4.4}/letify-core/Cargo.toml

@@ -8,7 +8,7 @@ resolver = "3"
 members = ["letify-wire", "letify-driver", "letify-agent", "letify-quic"]
 
 [workspace.package]
-version = "2.4.2"
+version = "2.4.4"
 edition = "2024"
 license = "MIT"
 repository = "https://github.com/DarkPyonix/letify"

{letify-2.4.2 → letify-2.4.4}/letify-ext/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "letify-status",
-  "version": "2.4.2",
+  "version": "2.4.4",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "letify-status",
-      "version": "2.4.2",
+      "version": "2.4.4",
       "license": "SEE LICENSE IN LICENSE",
       "devDependencies": {
         "@types/node": "^18.19.0",

{letify-2.4.2 → letify-2.4.4}/letify-ext/package.json

@@ -2,7 +2,7 @@
   "name": "letify-status",
   "displayName": "letify Status",
   "description": "letify quota and GPU activity in the status bar, read from the letify CLI.",
-  "version": "2.4.2",
+  "version": "2.4.4",
   "publisher": "darkpyonix",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {

{letify-2.4.2 → letify-2.4.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "letify"
-version = "2.4.2"
+version = "2.4.4"
 description = "Declarations that become infrastructure."
 readme = "README.md"
 requires-python = ">=3.11"

{letify-2.4.2 → letify-2.4.4}/tests/test_data_streaming.py

@@ -1365,3 +1365,189 @@ def test_the_patch_a_fresh_process_installs_arrives_through_sitecustomize() -> N
         )
     assert "SITECUSTOMIZE" in done.stderr, done.stderr
     assert "PTH" not in done.stderr, done.stderr
+
+
+def test_the_prune_leaves_a_live_call_its_blobs(launcher_from, project) -> None:
+    """Spec "Runtime data cache budget": a blob in flight for a running call is skipped.
+
+    A call is told which digests the runtime holds and does not send those, so a blob
+    removed between the answer and the use fails the call. A ten minute call outlived the
+    600 s recency window meant to carry it, and a second call beside it pruned 148 blobs
+    at once down to the budget, including ones the first had been told it had. Requests on
+    one channel may overlap, so the prune is sent here while the call is still running,
+    which is the same collision without the timing.
+
+    This passes without the guard as well: every shape that could be built quickly leaves
+    the blob with two links or a fresh use time, which the two older guards already cover.
+    It pins the behaviour the spec states rather than reproducing the failure, and the
+    reproduction is still open.
+    """
+    # Nothing in the first wave, so the call places its files while it runs and the ones
+    # it has not reached yet sit in the cache with a single link, which is the only state
+    # the old guards did not cover.
+    let = streaming(launcher_from, data_first_wave_mib=0)
+    root = dataset(project, 4, size=1 << 18)
+    started = threading.Event()
+
+    @let.function(device=let.providers.lab.CPU, host=letify.remote)
+    def reads(directory: Path, flag: str) -> int:
+        import os
+        import time
+
+        with open(flag, "w") as handle:
+            handle.write("in")
+        for _ in range(400):
+            if not os.path.exists(flag):
+                break
+            time.sleep(0.02)
+        total = 0
+        for entry in sorted(directory.iterdir()):
+            total += len(entry.read_bytes())
+        return total
+
+    flag = project / "running.flag"
+    answer: list = []
+
+    def call() -> None:
+        answer.append(reads(root, str(flag)))
+
+    with let.keep_alive():
+        # One call first, so every blob is in the cache before the call under test starts.
+        assert reads(root, str(project / "warm.flag")) == 4 * (1 << 18)
+        worker = threading.Thread(target=call, daemon=True)
+        worker.start()
+        for _ in range(200):
+            if flag.exists():
+                started.set()
+                break
+            time.sleep(0.02)
+        assert started.is_set(), "the call never reported that it had started"
+        runtime = next(
+            held for bucket in let.pool._runtimes.values() for held in bucket
+        )
+        root = (runtime.workspace or runtime.provider.workspace_root).rstrip("/")
+        # Budget zero, so the prune takes everything it is allowed to take.
+        runtime.request(
+            # recent 0, so only the live call's own guard can save its blobs.
+            {"op": "data_evict", "dir": f"{root}/data/blobs", "budget": 1, "recent": 0},
+            timeout=60,
+        )
+        flag.unlink()
+        worker.join(60)
+
+    assert answer == [4 * (1 << 18)], answer
+
+
+def test_a_write_back_that_fails_leaves_no_empty_directory(
+    launcher_from, project, monkeypatch
+) -> None:
+    """Spec "Writing back": a failed stream removes the directories it made.
+
+    A live session's write-back created four checkpoint directories whose files never
+    arrived, because the blobs they streamed from had been pruned, and a resume picked the
+    newest by name and found nothing in it. That cost about 2,300 steps.
+    """
+    let = streaming(launcher_from, data_first_wave_mib=1024)
+    out = project / "outputs"
+    out.mkdir()
+
+    @let.function(device=let.providers.lab.CPU, host=letify.remote)
+    def writes(directory: Path) -> int:
+        import os as _os
+
+        made = _os.path.join(str(directory), "checkpoint-2607")
+        _os.makedirs(made, exist_ok=True)
+        with open(_os.path.join(made, "trainer_state.json"), "wb") as handle:
+            handle.write(b'{"step": 2607}')
+        return 1
+
+    # The stream fails the way a pruned blob makes it fail.
+    from letify.store import pathdata as module
+
+    def refuse(runtime, payload):
+        raise letify.RuntimeFailure("data_stream failed: FileNotFoundError")
+
+    monkeypatch.setattr(module, "_stream", refuse)
+    with pytest.raises(letify.LetifyError):
+        writes(out)
+
+    assert not (out / "checkpoint-2607").exists(), sorted(
+        str(p.relative_to(out)) for p in out.rglob("*")
+    )
+
+
+def test_a_write_back_leaves_a_directory_that_was_already_there(
+    launcher_from, project, monkeypatch
+) -> None:
+    """Spec: a directory that already existed, or that holds anything, is left alone."""
+    let = streaming(launcher_from, data_first_wave_mib=1024)
+    out = project / "outputs"
+    (out / "checkpoint-2607").mkdir(parents=True)
+    (out / "checkpoint-2607" / "kept.txt").write_text("mine", encoding="utf-8")
+
+    @let.function(device=let.providers.lab.CPU, host=letify.remote)
+    def writes(directory: Path) -> int:
+        import os as _os
+
+        made = _os.path.join(str(directory), "checkpoint-2607")
+        with open(_os.path.join(made, "trainer_state.json"), "wb") as handle:
+            handle.write(b'{"step": 2607}')
+        return 1
+
+    from letify.store import pathdata as module
+
+    def refuse(runtime, payload):
+        raise letify.RuntimeFailure("data_stream failed: FileNotFoundError")
+
+    monkeypatch.setattr(module, "_stream", refuse)
+    with pytest.raises(letify.LetifyError):
+        writes(out)
+
+    assert (out / "checkpoint-2607" / "kept.txt").read_text(encoding="utf-8") == "mine"
+
+
+def test_the_cache_says_when_it_drops_a_blob_written_through_its_link() -> None:
+    """Spec "Runtime data cache budget": a dropped blob is reported, not silent.
+
+    A live session spent two days unable to tell this removal from the budget prune,
+    because a blob vanished and only the next failure mentioned it.
+    """
+    from letify.protocol import worker
+
+    at = worker.SOURCE.index("def _data_check_cache")
+    body = worker.SOURCE[at : worker.SOURCE.index("\ndef ", at + 10)]
+    assert "data cache dropped" in body
+    assert "written through its link" in body
+    assert "sys.stderr" in body
+
+
+def test_a_blob_whose_bytes_are_unchanged_survives_a_new_mtime(launcher_from, project) -> None:
+    """Spec "Runtime data cache budget": dropped on content, not on a timestamp.
+
+    A session restoring its blobs by copying them back had each copy dropped again on its
+    new mtime, so a loop meant to repair the store kept emptying it.
+    """
+    let = streaming(launcher_from, data_first_wave_mib=1024)
+    root = dataset(project, 1, size=1 << 12)
+    target = root / "000.bin"
+
+    @let.function(device=let.providers.lab.CPU, host=letify.remote)
+    def touches(path: Path) -> list[int]:
+        import os as _os
+
+        info = _os.stat(path)
+        # The same bytes, a new timestamp: what a copy back looks like.
+        _os.utime(path, (info.st_atime, info.st_mtime + 120))
+        return [info.st_nlink, _os.stat(path).st_size]
+
+    links, size = touches(target)
+    assert links == 2 and size == 1 << 12
+
+    # The blob is still there, so a second call is told the runtime has it.
+    import io
+    from contextlib import redirect_stderr
+
+    captured = io.StringIO()
+    with redirect_stderr(captured):
+        assert touches(target)[1] == 1 << 12
+    assert "data cache dropped" not in captured.getvalue()