Perforce Storage Optimization
p4-cache transparently tiers cold Perforce depot data to object storage while keeping hot data on fast NVMe — no p4d patches, no client changes.
The Problem
As depots grow, the economics stop making sense — most of what you're paying premium prices to store is barely ever touched.
5–15%
of depot data is actually read in any 30-day window.
85–95%
of data sits idle on premium storage tiers, costing you every month regardless.
Linear
SAN and cloud SSD costs scale directly with depot growth — there's no natural ceiling.
How It Works
p4-cache sits underneath Perforce as a lightweight daemon — your developers and your p4d server never know it's there.
The daemon initializes a metadata map of every file in the depot, tracking access recency without touching the underlying data.
An LD_PRELOAD shim intercepts file reads transparently, serving hot files instantly from local NVMe and fetching cold files from object storage on demand.
Submits land on local storage first for full-speed commits, then move asynchronously to the appropriate cloud tier based on access policy.
Architecture
p4-cache runs as a lightweight Rust daemon paired with an LD_PRELOAD library that intercepts file-level I/O without modifying p4d or requiring any client-side changes.
Cold reads are served from your object storage backend of choice — Azure Blob, Amazon S3, Google Cloud Storage, or NFS — and promoted to local NVMe cache automatically as they're accessed.
Writes commit locally first, keeping submit latency untouched, then move to cold storage asynchronously according to configurable tiering policy.
Storage Efficiency
Optional content de-duplication recognizes archive data that is byte-for-byte identical — vendor libraries, common third-party binaries, re-added drops — and keeps a single copy in cold storage instead of one per depot path. Savings that stack on top of tiering.
Identical bytes are identified by a cryptographic content hash and stored a single time; every path that holds that content serves from the one shared copy.
A read-only tool reports exactly how much is reclaimable on your depot before you enable anything. Savings are workload-dependent — you see the real number first.
Off by default and enabled per deployment. De-duplicated content stays encrypted and cryptographically verified, and works with p4-cache's existing deletion controls.
Business Case
$100k+/yr
Typical savings with ROI inside the first year of deployment.
$3M+/yr
Ongoing savings, with no future storage refresh cycle required.
Security & Reliability
The daemon and shim layer undergo regular third-party security audits, with findings and remediations tracked and disclosed.
Every object moved between tiers is checksummed and verified on write and on read, so cold data is provably identical to what Perforce originally stored.
All data moving to and from cloud tiers is encrypted in transit, and rests behind your chosen cloud provider's encryption-at-rest controls.
If a cloud backend is unreachable, reads and writes fail safe rather than corrupting depot state, with clear operator-facing error signals.
Prometheus metrics and structured logs expose cache hit rates, tier movement, and daemon health for your existing monitoring stack.
Designed for Perforce administrators and platform engineering teams who need predictable, low-maintenance storage economics at scale.
Resources
P4-Cache