Scene 04

Persistence — fork, CoW, and the 1-second window

RDB forks a child that writes the dataset via copy-on-write, and AOF's everysec fsync trades up to one second of writes for throughput — together they define what 'durable Redis' actually means.

Previously

You've seen what's in RAM and how it's encoded. None of it survives a crash on its own — persistence is how the live keyspace becomes bytes on disk.

Scene 04

Persistence — fork, CoW, and the 1-second window

Watch
Try it
Predict
Capture

What to watch for

Watch writes land on the AOF tail (amber = buffered) and flip emerald when the everysec fsync fires. After a few seconds, BGSAVE forks a child — pages start flipping orange one by one as the parent keeps writing during the snapshot.

Implementation

Highlighted lines are the ones running in the diagram right now.

Server.bgsave()

fork a child; parent keeps serving on copy-on-write pages

1def bgsave():
2    pid = fork()
3    if pid == 0:
4        # child: frozen view of memory at fork time
5        writeRDB(snapshot=heap_snapshot())
6        exit(0)
7    # parent returns immediately; serves clients
8    # while pages diverge via CoW on each write.
9    return pid

Server.handleWrite(cmd)

mutate memory, append to AOF buffer, reply OK

1def handleWrite(cmd):
2    apply(cmd, db)            # in-memory mutation
3    aof_buf.append(cmd)       # OS page-cache write
4    if cfg.appendfsync == 'always':
5        fsync(aof_fd)         # block until on disk
6    reply_ok(client)          # ack returns to caller

aofFlushBackground() # everysec

background thread fsyncs the AOF once per second

1def aofFlushBackground():
2    last_fsync = now()
3    while running:
4        if now() - last_fsync >= 1.0:
5            fsync(aof_fd)
6            last_fsync = now()
7        sleep(0.1)

kernel.pageWrite(page)

first parent write to a shared page triggers the copy

1def pageWrite(page):
2    if page.shared:
3        new = copy_page(page)  # 4 KB, or 2 MB under THP
4        page.shared = False
5        mark_copied(page, new)
6    write_into(page)

Sources

Where this sits in Build Redis

Scene 04 of 10, in the Memory act — Persistence, eviction, TTL — what makes RAM disappear.. RDB snapshots via fork+CoW, AOF fsync policies, and why default Redis can lose ~1s of writes on crash.

Up next. Eviction — persistence handles the crash. But while the process is running and RAM fills up, who has to leave to make room for the next write?

All 10 scenes in Build Redis · Every curriculum

Designs that use this

Built with Arqly

Every scene in Build Redis builds on the one before it.All 10 Build Redis scenes