Benchmarks

Results

• PutFS serves concurrent small file reads 2-3x faster than MinIO
• PutFS writes are 1.6-5x faster than MinIO
• PutFS directory listings are 10-65x faster, the gap growing with directory size
• PutFS uses 37x less memory
• PutFS reads a 1 GB file 2x faster
• MinIO wins on bulk parallel uploads (mc mirror vs putfs sync)

Both backends ran on the same server and the same ext4 SSD, PutFS as the Rust build behind nginx, see Test setup.

Small file random reads (10K files, 1K–100K, wrk, 30s)

nginx serves files via sendfile straight from the page cache; the app server is never involved, so reads are the same for every PutFS build.

Single-file write latency (hyperfine, mean)

Each size re-uploads one key, so every run after the first replaces an existing object. ext4 writes a file's data out when a rename replaces another file (auto_da_alloc, on by default), so from 10 MB on PutFS writes at disk speed. A new key does not pay this:

Bulk upload (10K files, 1K–100K)

Go's native concurrency in mc mirror beats the threaded Python putfs sync.

Large file sequential read (1 GB)

PutFS is read with curl (nginx sendfile), MinIO with mc cat.

Directory listing

One full listing per run, client process included (curl with QUERY vs mc ls), which is most of the 1K figure. For the server's walk alone see the wrk listing numbers below.

Memory footprint (idle)

PutFS uses 37x less memory. This is each container's anonymous memory (heap, stacks) from its cgroup, sampled after the run and unchanged under 100 concurrent readers.

Summary

Test setup

Both ran in docker on the same server, with their data on the same local SSD (ext4) and the benchmark clients on the host. The seed and write source files were generated on a tmpfs (TESTDATA_DIR), off that SSD.

Tuning

• PutFS:
  • the Rust build (docker-compose.rust.yml) on a unix socket
  • nginx, no access logs
• MinIO:
  • MINIO_API_REQUESTS_MAX: "0"
  • MINIO_SCANNER_SPEED: "fastest"
  • MINIO_BROWSER: "off"
  • GOMAXPROCS: "0"

Hardware

Running

Scripts live in benchmark/ (README); results are read with analyze.sh, one CSV column per result directory:

The two backends run as separate commands, never in one sequence, so the disks can be wiped or re-laid between them. TESTDATA_DIR (default /tmp, about 12 GB) keeps the generated files off the backend's disk.

docker compose -f docker-compose.yml -f docker-compose.rust.yml up -d --build   # PutFS: the Rust build behind nginx
make -C benchmark putfs
# tear down, wipe or re-lay the disks
docker compose -f contrib/docker-compose.minio.yml up -d
make -C benchmark minio
bash benchmark/analyze.sh benchmark/results/minio/putfs benchmark/results/minio/minio

Implementation comparison (Python / Go / Rust)

The Go and Rust ports share the Python build's HTTP API; only the language differs. This benchmark isolates the app-server hot path (PUT / DELETE / LIST; GET/HEAD are nginx's job in production) by running each server bare on localhost, no nginx, no auth, driven by wrk.

Parallel PUT throughput (4 KB objects, wrk)

Directory listing (wrk, keep-alive)

• Listing: Rust wins, ~1.7–2.0× Go and ~5–10× Python, widening with directory size.
• Writes: Rust leads at c10 (~1.6× Go), Go at c100 (~1.9× Rust), c1 is a tie. Rust offloads each PUT's open and rename to a thread pool (as Python's anyio.to_thread does), which costs it only at high fan-out.
• Both ports are ~5–13× Python on writes. Python's per-line async listing tops out at ~240–270k keys/s regardless of size.

Intel Core i7-1360P (16 threads), 30 GB RAM, Debian forky/sid (kernel 7.0.10); bare servers on localhost, page cache, mean of three wrk runs. Not the server of the MinIO comparison.

make build-rust build-go     # the native binaries (repo-root Makefile)
cd benchmark
make impls                   # python + go + rust
bash analyze.sh results/impls/*