VLDB 2026 · R_GET = T · λ · ρ · k

Neon + WarpDrive · S3 Operation Characterization

sysbench-tpcc · scale=10 · 120s per run · Phase 9 config · 2026-07-17
Neon main · sysbench 1.0.20 · WarpDrive feat/op-counters

● PUT — layer upload ● GET — layer download ● DELETE_OBJECTS — compaction GC ● delta vs image GET breakdown ◈ Slab 4MB cold (co-located)
PUT / COPY / POST / LIST
$0.005
per 1,000 · write tier
GET / HEAD
$0.0004
per 1,000 · read tier
DELETE_OBJECTS (batch)
$0.005
write tier · up to 1,000 keys/call
DELETE (single object)
free
Neon always uses batch DELETE_OBJECTS
Cost = (GET + HEAD) × $0.0004 / 1000 + (PUT + COPY + LIST + DELETE_OBJECTS) × $0.005 / 1000
checkpoint_distance 4 MB checkpoint_timeout 5s eviction_policy LayerAccessThreshold(10s) threads 4 / endpoint · duration 120s protocol wipe layers → restart pageserver → reset metrics → start T endpoints → sysbench

TPS — Total & Per-Tenant vs Tenant Count

Baseline total TPS stalls at ~35–39 across T=1–8 then collapses to 4.1 at T=16 as the pageserver drowns in cold-start GET amplification (2,981 GETs). Slab 4MB sustains 41.8 TPS at T=16 — a 10× improvement — because co-located layer storage cuts startup GETs and frees pageserver capacity. At T=1–4 slab also runs faster: 51.8 and 55.7 TPS vs 35.4 and 35.6, benefiting from a dramatically lighter cold-start read path. TPS/tenant falls steeply in both variants as the single pageserver saturates, but the slab curve degrades far more gracefully.

GET Amplification — Delta vs Image vs Tenant Count

Baseline GETs spiral super-linearly: 68 → 109 → 954 → 2,981 at T=16 (44×), driven by eviction thrashing as timelines compete for pageserver memory. Slab cuts GETs to 6 at T=1 (11× fewer) — cold-start delta reads nearly disappear. At T=4 slab generates more GETs than baseline (220 vs 109), suggesting the 4 MB window is too small to fully co-locate concurrent timelines. At T=8–16 slab's eviction pressure is far lower: 287 and 231 GETs vs 954 and 2,981 — 3–13× fewer reads at scale.

PUTs & DELETE_OBJECTS vs Tenant Count

PUTs track WAL throughput, not storage layout, so both variants follow similar shapes. Baseline peaks at T=4 (1,123 PUTs) when TPS is highest; slab peaks later at T=16 (789) because it sustains throughput longer. DELETE_OBJECTS (compaction GC) is minimal in both — billed at write-tier rates ($0.005/1k) despite doing no user-visible work.

Latency (avg & p95) vs Tenant Count

The gap is starkest at T=16: baseline avg latency hits 63,692 ms (endpoints blocked waiting for delta chain downloads) vs slab's 603 ms — a 105× difference. Baseline p95 hits the 100s cap at T=16 with several endpoints unable to complete a single transaction; slab p95 is 5.9s at the same point. At T=1–8 profiles are broadly similar, reflecting that startup GET pressure — not slab co-location per se — is the primary bottleneck at lower concurrency.

Full Results

T Total TPSTPS / tenantAvg latp95 lat PUTs GETs ↳ delta ↳ image DEL_OBJ Est. cost

Pageserver Layer Lifecycle · why GETs amplify super-linearly with tenant count

WAL stream
ingested by pageserver
→
PUT
delta layer uploaded
at checkpoint boundary
→
idle > 10s
eviction removes
from local disk
→
compaction wins →
DELETE_OBJECTS
superseded delta GC'd · never re-read
read arrives first →
GET
on-demand fetch from WarpDrive
Cold start: every run wipes local layer files and restarts the pageserver, so each endpoint must re-download its working set from WarpDrive on first page access. Startup GETs are purely cold reads; benchmark GETs are eviction-driven mid-run re-fetches.

Super-linear GET growth (68 → 109 → 442 → 768 for T=1,4,8,16): more tenants means more timelines competing for pageserver I/O, higher eviction pressure per timeline, and cold-start downloads that pile up linearly across timelines. Delta GETs account for ~89% across all T — each delta GET requires k independent WarpDrive round-trips to reconstruct a page.

On a flat immutable object store, S3 forces the full PUT → evict → DELETE_OBJECTS/GET cycle. WarpDrive's co-located mutable slabs collapse this: append-in-place eliminates the GC cycle, and cold reads resolve in one batched I/O rather than k sequential round-trips.
R_GET = T · λ · ρ · k
T = tenants  ·  λ = request rate per tenant  ·  ρ = cache miss rate  ·  k = delta layers needed per page reconstruction

Measured scaling: T=1 → 68 GETs (58Δ+10img)  ·  T=4 → 109 GETs (97Δ+12img)  ·  T=8 → 954 GETs (764Δ+190img)  ·  T=16 → 2,981 GETs (2583Δ+398img)
Delta fraction ≈85% across all T — page reconstruction cost dominates, not image warmup.

Super-linear growth is explained by ρ rising with T: multi-tenant eviction pressure increases the miss rate faster than T grows. GET:PUT ratio rises from 0.23 (T=1) to 3.51 (T=16) — the system spends 3.5× more on reads than writes at full load.

DELETE_OBJECTS scales with compaction GC frequency — write-tier billed, 3→3→6→12 across T=1,4,8,16. WarpDrive mutable slabs eliminate this entirely.