Benchmark Methodology
How BrewFS measures and reports filesystem performance.
BrewFS reports performance as a property of a specific workload and profile, not as a universal filesystem ranking. Every published result should identify the backend, cache state, mount behavior, workload shape, host, software revision, and the exact runner command.
Current Redis + RustFS reference setup
The published July 24, 2026 comparison snapshot uses the same host for both filesystems:
| Item | Configuration |
|---|---|
| Metadata | Redis |
| Object storage | RustFS, S3-compatible |
| Compression | Disabled for both sides |
| fio access | Buffered fio I/O (direct=0) with io_uring and iodepth=1 |
| fio block size | 4 MiB for the published throughput profiles |
| Per-job size / runtime | PERF_FIO_SIZE=512m; time-based workloads run for 20 seconds |
| Workload shape | Matching fio job shapes; Large read/write transfer 4 GiB with eight jobs |
| Host | Intel Xeon Platinum, 8 vCPU, 14 GiB available memory, Linux 6.8.0 |
| Storage | 130 GiB virtual block device |
BrewFS Redis uses commit_before_upload, 2 GiB read and write memory caches, an
8 GiB persistent read cache, a 4 GiB SSD writeback cache, six writeback upload
workers, S3 concurrency 8, and upload concurrency 16. JuiceFS uses
writeback=true, a 4 GiB buffer, an 8 GiB persistent cache,
cache-large-write, four upload connections, and four stage-write threads.
Read rows use durable prefill and a cache-preserving remount; writes report both
application-visible tool-wall throughput and fully drained throughput after the
queue reaches zero.
Representative Redis results
Across 14 application-visible data rows and 10 metadata rows, BrewFS leads 15 of 24 matched rows (10 of 14 data-path, 5 of 10 metadata). Stable persistent-cache Large read is effectively tied. JuiceFS still leads sequential read, strictly drained pure writes, and TiKV create/open/rename.
| Workload | BrewFS | JuiceFS | Advantage |
|---|---|---|---|
| Random read | 1,726.10 MiB/s | 1,256.80 MiB/s | 37% faster (~1.37x) |
| Foreground mixed random I/O | 495.54 MiB/s | 328.76 MiB/s | 51% faster (~1.51x) |
| Foreground Large write | 195.05 MiB/s | 102.40 MiB/s | 90% faster (~1.90x) |
| Fully drained mixed random I/O | 218.60 MiB/s | 113.86 MiB/s | 92% faster (~1.92x) |
| Hot local-cache Large read | 2,395.32 MiB/s | 2,356.73 MiB/s | ~2% faster |
| Metadata create | 1,004.61 ops/s | 549.01 ops/s | 83% faster (~1.83x) |
| Readdir | 28,634.94 ops/s | 16,020.25 ops/s | ~1.79x |
Fully drained throughput is actual fio bytes divided by active I/O time plus post-write drain, so a larger unflushed queue does not inflate the write result. No geometric-mean summary is published for this snapshot.
These values are useful for the listed configuration and workload only. They do not predict cold-cache, larger-than-cache, remote-network, or differently tuned deployments.
Reproduce the profiles
# BrewFS comparison profile
PERF_LOG_TO_CONSOLE=false PERF_FIO_SIZE=512m PERF_FIO_RUNTIME=20 \
bash docker/compose-xfstests/run_redis_perf.sh --s3 --writeback-throughput-profile
# JuiceFS comparison profile
JUICEFS_META_BACKEND=redis PERF_LOG_TO_CONSOLE=false \
PERF_FIO_SIZE=512m PERF_FIO_RUNTIME=20 \
bash docker/compose-xfstests/run_juicefs_perf.sh --writeback-throughput-profileCompose runners write raw reports and logs below
docker/compose-xfstests/artifacts/. Keep those artifacts with the report so a
claim can be traced to its inputs and output.
Fair-comparison rules
- Report cold and warm cache separately; a microsecond read may be a cache hit, not an object-store read.
- Keep workload shape, data set, backend, host, mount options, compression, and runtime settings explicit.
- Name any semantic trade-off.
commit-before-upload, read-only direct I/O, and write-open caching are opt-in profiles, not default guarantees. - Run the target workload at least three times and report the median.
- Keep non-target fio and metadata regressions within a 5% budget.
- Re-run the POSIX suites whenever a hot-path change can affect filesystem behavior; see POSIX Testing.
Interpreting the result
Do not attribute a result to Rust alone. Cache warmth, dirty-overlay behavior, metadata round trips, batching, and FUSE runtime behavior are all measured variables. The performance data is strongest when those variables are recorded, compared, and made falsifiable.

