The page cache is a queue before it is durable storage

In the usual buffered path, an application supplies bytes and the kernel updates cached file contents, marking the affected memory dirty. Readers can observe these new contents through the filesystem's normal coherence behavior before those bytes are persistent. Later, writeback submits data toward storage and updates bookkeeping when operations finish. Filesystem allocation, metadata updates, block-layer handling, and device caching can all participate. The exact path depends on filesystem and I/O mode, so label each measurement by the boundary it observes instead of reporting one ambiguous write-completion time.

A successful write call returns a byte count, which may be smaller than requested. Handle partial progress and errors before assuming a complete record was accepted. A later writeback failure may surface at synchronization or another documented reporting point. Closing a descriptor or flushing a language-level buffer is not a substitute for the storage synchronization contract. Conversely, forcing every tiny update separately can destroy useful batching. Choose a commit boundary that matches the application promise, such as a durable checkpoint generation, and measure its cost explicitly.

Suppose a writer generates data faster than writeback can drain it. Initially the difference accumulates in available memory, and the application's observed rate can exceed persistent device throughput. Eventually memory policy, dirty limits, contention, or explicit synchronization constrains progress. The resulting drop is not automatically a defective device; it may be the transition from borrowing memory to paying the sustained cost. A benchmark must run long enough, or explicitly synchronize and account for draining, to expose the boundary its conclusion concerns.

When producers stop, dirty bytes still take time to drain. Data already read into a clean cache can make a later read benchmark measure memory rather than storage. Read and write caching therefore need separate treatment. Record the working-set size, I/O mode, cache preparation method, concurrency, and synchronization protocol with results. Bypassing the page cache does not by itself prove power-loss durability, because a device may still acknowledge writes into its own volatile cache. Performance and persistence boundaries remain separate even when one buffer is removed.

Watch admitted application bytes, dirty/writeback memory, completed device bytes, and end-to-end synchronization latency over the same time interval. Filesystem or device write amplification can make device bytes exceed application bytes; compressible data can also complicate comparisons. A falling dirty count does not alone prove the latest application transaction survived all required failure modes. Associate acknowledgments with checked synchronization results and keep delayed errors visible to the component that decides whether a model artifact may be advertised as ready.

The queue lab captures the simplest pressure balance. Treat one job as one chosen data unit. Press Reset, set both arrival to four and service to two, predict growth from the initial four-unit backlog, then Play or Step. For a separate drainage run, press Reset again, set both arrival to one and service to three, predict drainage from four, then Play or Step. A slider edit pauses but retains elapsed time and recalculates from the initial four; it does not switch a live accumulated backlog to new rates. The separate M/M/1 readout assumes Poisson arrivals, exponential service, and a stable single server, not Linux writeback.