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)
S3 Pricing Reference · AWS us-east-1 2025
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
Multi-Tenant Cold-Start Scaling · T = 1, 4, 8, 16
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.
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.