FUSE Mount vs Native Disk I/O Performance Benchmarks in Cloudflare Computer

The Cloudflare Computer FUSE driver achieves near-native read performance (~28 ms vs 26 ms) with kernel caching enabled, but write-heavy workloads incur 6–8× overhead due to SQLite-backed chunking and synchronous flushing.

The computerd binary in the cloudflare/computer repository implements a FUSE filesystem that balances performance against safety guarantees. This article breaks down the official benchmark suite, explains the latency trade-offs between caching modes, and shows how to reproduce the measurements yourself.

Benchmark Results: FUSE Mount vs Native Disk I/O

The definitive results live in [packages/computerd/bench-results.md](https://github.com/cloudflare/computer/blob/main/packages/computerd/bench-results.md). All timings represent the mean of three repetitions with one warm-up, measured in milliseconds:

Scenario	Native baseline (ms)	Default auto-cache (ms)	Kernel cache (ms)
Write 64 MiB	32.3	213.7	—
Pure read 64 MiB	26.0	45.3	28.4
Pure copy 64 MiB	32.3	252.3	245.4
Overwrite 64 MiB	28.9	185.9	185.4

These figures establish the baseline for FUSE mount vs native disk I/O performance comparisons in the project.

Read Performance: Closing the Gap with Kernel Cache

Read-only workloads benefit dramatically from kernel page-cache reuse.

The default auto-cache profile completes pure reads in ~45 ms—roughly 1.7× slower than native disk. Enabling kernel cache (COMPUTERD_FUSE_AUTO_CACHE=0 plus COMPUTERD_FUSE_KERNEL_CACHE=1) drops this to ~28 ms, nearly matching the 26 ms native baseline.

This optimization works because the kernel reuses page-cache entries across reads of identical offsets. Each read call avoids a fresh FUSE round-trip, eliminating the userspace↔kernel boundary crossing that dominates FUSE latency.

Write Performance: The SQLite Chunking Bottleneck

Write-heavy workloads show consistent 6–8× overhead regardless of cache configuration.

Both auto-cache and kernel-cache profiles produce similar timings for write (~186–214 ms), copy (~245–252 ms), and overwrite (~185 ms) operations. The cache options do not affect this path because:

• The driver buffers writes in memory
• On flush, it invokes vfs.writeFileSync to persist the entire file
• This ultimately hits the SQLite-backed chunking layer (@cloudflare/dofs)

The overhead is structural: chunking, deduplication, and transactional safety add latency that caching cannot eliminate.

Cache Safety Trade-offs

The performance difference between cache modes carries a critical safety caveat.

Auto-Cache (Production-Safe Default)

• Invalidates the page cache on open() when mtime or file size changes
• Prevents stale reads when concurrent containers modify files
• Verified by tests in [packages/computerd/src/fuse/driver.test.ts](https://github.com/cloudflare/computer/blob/main/packages/computerd/src/fuse/driver.test.ts) and [packages/dofs/src/sync/apply.test.ts](https://github.com/cloudflare/computer/blob/main/packages/dofs/src/sync/apply.test.ts)

Kernel Cache (Unsafe for Concurrent Writers)

• Declares the page cache never invalidates
• Risk: if a sync pushes new bytes while another container holds the file open, the kernel may serve stale data
• Acceptable only for read-only or single-writer scenarios

Running the Benchmark Suite

The benchmark harness lives in [script/run-fs-bench.sh](https://github.com/cloudflare/computer/blob/main/script/run-fs-bench.sh). It orchestrates Docker-privileged containers with FUSE device access.

Standard Invocation

# Build the linux-x64 computerd binary

npm run build:bin --workspace @cloudflare/computerd

# Run the benchmark

docker run --rm --platform linux/amd64 --privileged \
  --device /dev/fuse --cap-add SYS_ADMIN --cap-add MKNOD \
  -v "$PWD/artifacts/computerd/computerd-linux-x64:/usr/local/bin/computerd:ro" \
  -v "$PWD/script/fs-bench.sh:/usr/local/bin/fs-bench:ro" \
  -v "$PWD/script/run-fs-bench.sh:/run-bench.sh:ro" \
  -v "$PWD/bench-out:/out" \
  -e REPS=3 -e WARMUP=1 \
  -e OUTPUT_JSON=/out/results.json \
  -e SCENARIOS='pure read,pure copy,overwrite,write 64' \
  debian:stable-slim bash /run-bench.sh

The benchmark creates fresh subdirectories per repetition, ensuring each scenario reads its target exactly once per timed sample. This isolates the FUSE path and dirty-buffer spill logic but does not exercise kernel page-cache reuse across multiple opens.

Testing Kernel Cache Mode

COMPUTERD_FUSE_AUTO_CACHE=0 COMPUTERD_FUSE_KERNEL_CACHE=1 \
docker run ...  # same flags as above

Configuration Examples

Default Safe Profile (Auto-Cache)

import { startComputerd } from "@cloudflare/computer";

await startComputerd({
  fuseOptions: {
    // Production defaults apply automatically
  },
});

Kernel Cache Profile (Unsafe, Maximum Read Speed)

import { startComputerd } from "@cloudflare/computer";

await startComputerd({
  env: {
    COMPUTERD_FUSE_AUTO_CACHE: "0",
    COMPUTERD_FUSE_KERNEL_CACHE: "1",
  },
});

Programmatic Benchmark Execution

import { execSync } from "child_process";

// Build binary
execSync("npm run build:bin --workspace @cloudflare/computerd", { stdio: "inherit" });

// Configure kernel cache mode
process.env.COMPUTERD_FUSE_AUTO_CACHE = "0";
process.env.COMPUTERD_FUSE_KERNEL_CACHE = "1";

// Run benchmark
execSync("bash script/run-fs-bench.sh", { stdio: "inherit" });

Key Source Files

File	Purpose
[script/run-fs-bench.sh](https://github.com/cloudflare/computer/blob/main/script/run-fs-bench.sh)	Docker-based benchmark orchestration
[packages/computerd/bench-results.md](https://github.com/cloudflare/computer/blob/main/packages/computerd/bench-results.md)	Official results and analysis
[packages/computerd/src/fuse/driver.test.ts](https://github.com/cloudflare/computer/blob/main/packages/computerd/src/fuse/driver.test.ts)	Cache safety validation
[packages/dofs/src/sync/apply.test.ts](https://github.com/cloudflare/computer/blob/main/packages/dofs/src/sync/apply.test.ts)	Sync-apply correctness tests
[packages/computerd/README.md](https://github.com/cloudflare/computer/blob/main/packages/computerd/README.md)	Daemon overview and caching options

Summary

• FUSE mount vs native disk I/O shows 1.1× read latency with kernel cache, 6–8× write overhead due to SQLite chunking
• Kernel cache (COMPUTERD_FUSE_KERNEL_CACHE=1) achieves near-native reads but is unsafe for concurrent writers
• Auto-cache is the production default, trading ~75% read performance for cache invalidation safety
• Write performance is cache-agnostic; overhead stems from vfs.writeFileSync and the @cloudflare/dofs persistence layer
• Reproduce all measurements via [script/run-fs-bench.sh](https://github.com/cloudflare/computer/blob/main/script/run-fs-bench.sh) with Docker-privileged containers

Frequently Asked Questions

How close can FUSE mount performance get to native disk I/O for reads?

With kernel cache enabled, the Cloudflare Computer FUSE driver achieves ~28 ms for 64 MiB pure reads versus 26 ms native—a 7.7% overhead. The kernel page cache eliminates FUSE round-trips by reusing entries across reads of identical offsets.

Why doesn't kernel cache improve write performance?

Write operations follow a fixed path: memory buffer → vfs.writeFileSync → SQLite chunking in @cloudflare/dofs. Cache options only affect read-side page cache behavior; they do not bypass the transactional persistence layer that ensures data integrity.

Is kernel cache safe to enable in production?

No—unless you guarantee single-writer or read-only access patterns. Kernel cache tells the kernel the page cache never invalidates. If a background sync modifies a file while another container holds it open, subsequent reads may return stale data. The auto-cache default prevents this by validating mtime and size on every open().

What hardware or environment skews these benchmarks?

The published results assume local SSD storage, Linux kernel 5.x+, and Docker with --privileged FUSE access. Network-attached storage, virtualization layers, or constrained CPU/memory environments would alter the absolute timings—though the relative performance ratios between cache modes should hold.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}