Simulate a cold start without rebooting or drop_caches

Steps#

1. Save the eviction script as evict.py.

   import os, sys
   
   for path in sys.argv[1:]:
       fd = os.open(path, os.O_RDONLY)
       try:
           os.posix_fadvise(fd, 0, 0, os.POSIX_FADV_DONTNEED)
       finally:
           os.close(fd)
   

   Offset 0 and length 0 cover the whole file. The script prints nothing and exits 0 even when the kernel keeps pages; only step 6 tells you whether it worked.
2. Make sure no container is running the file.

   $ docker ps --filter volume=/app --format '{{.Names}} {{.Status}}'
   

   Expected: no output (volume= matches the mount destination inside the container). If a name is printed, remove that container first: pages a running process has mapped stay in the cache (Failure modes, row 1).
3. Check what is cached now.

   $ fincore app/demo-micronaut
     RES PAGES  SIZE FILE
   52.2M 13373 67.4M app/demo-micronaut
   

   RES is the part of the file in the page cache. Here 52.2M was left over from an earlier start.
4. Write out dirty pages of the file.

   $ sync app/demo-micronaut
   

   Expected: no output. posix_fadvise(2) does not free dirty pages that have not been written back. On the test box a freshly written 64 MiB file reached 0 B without this step, so it is a cheap precaution, not a fix for an observed failure.
5. Evict the file.

   $ python3 evict.py app/demo-micronaut
   

   Expected: no output, exit status 0.
6. Confirm nothing of the file is cached.

   $ fincore app/demo-micronaut
   RES PAGES  SIZE FILE
    0B     0 67.4M app/demo-micronaut
   

   Expected: 0B and 0 pages. Anything else: Failure modes, rows 1 and 2.
7. Start the program; it is now the first reader of the file. Here a native binary in a container with a 64 MiB limit (-m 64m):

   $ docker run -d --name cold-demo -m 64m --memory-swap 64m -p 127.0.0.1:18080:8080 -v "$PWD/app:/app:ro" debian:bookworm-slim /app/demo-micronaut -XX:MaxHeapSize=32m
   feb26a504b88824bbac72cd6835307764c0ccbcc33f7ab44759041e4900437d2
   $ for i in $(seq 100); do curl -sf http://127.0.0.1:18080/hello && break; sleep 0.2; done; echo
   {"runtime":"native","pid":1,"framework":"micronaut"}
   

   Expected: the container ID, then the first answer from the app. Wait with a loop like this one, not with curl --retry (Failure modes, row 4).
8. Read what the container's cgroup was charged for the page cache.

   $ grep -E '^(anon|file|file_mapped) ' /sys/fs/cgroup/system.slice/docker-$(docker inspect -f '{{.Id}}' cold-demo).scope/memory.stat
   anon 10444800
   file 54722560
   file_mapped 32153600
   

   Expected: a large file value, here 54,722,560 bytes (52.2 MiB). The container read the binary first, so the page cache it loaded counts against its own memory limit. A warm start shows file at or near 0 (Verify).
9. Remove the container. The next start is warm again.

   $ docker rm -f cold-demo
   cold-demo
   $ fincore app/demo-micronaut
     RES PAGES  SIZE FILE
   52.2M 13360 67.4M app/demo-micronaut
   

   The cold start left 52.2M of the file in the cache.
10. For several rounds, evict before every start. Save as cold-rounds.sh:

    #!/usr/bin/env bash
    # Three cold starts of a bind-mounted binary; the page cache is evicted before each one.
    set -u
    BIN=app/demo-micronaut
    for round in 1 2 3; do
      python3 evict.py "$BIN"
      fincore "$BIN" | tail -1
      docker run -d --name cold-demo -m 64m --memory-swap 64m -p 127.0.0.1:18080:8080 \
        -v "$PWD/app:/app:ro" debian:bookworm-slim /app/demo-micronaut -XX:MaxHeapSize=32m > /dev/null
      for i in $(seq 100); do curl -sf http://127.0.0.1:18080/hello > /dev/null && break; sleep 0.2; done
      cg=/sys/fs/cgroup/system.slice/docker-$(docker inspect -f '{{.Id}}' cold-demo).scope
      echo "round $round: $(curl -s http://127.0.0.1:18080/hello) $(grep '^file ' "$cg/memory.stat")"
      docker rm -f cold-demo > /dev/null
    done
    

    $ bash cold-rounds.sh
     0B     0 67.4M app/demo-micronaut
    round 1: {"runtime":"native","pid":1,"framework":"micronaut"} file 54546432
     0B     0 67.4M app/demo-micronaut
    round 2: {"runtime":"native","pid":1,"framework":"micronaut"} file 54960128
     0B     0 67.4M app/demo-micronaut
    round 3: {"runtime":"native","pid":1,"framework":"micronaut"} file 54734848
    

    Expected: 0B before every round and a similar file value in each. A round with an empty answer after round N: did not start within the 20 s the loop waits.