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

> Compare FUSE mount vs native disk I/O performance in Cloudflare Computer. Discover near-native read speeds and understand write overheads.

- Repository: [Cloudflare/computer](https://github.com/cloudflare/computer)
- Tags: performance
- Published: 2026-08-16

---

**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](https://github.com/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)](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)](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)](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)](https://github.com/cloudflare/computer/blob/main/script/run-fs-bench.sh). It orchestrates Docker-privileged containers with FUSE device access.

### Standard Invocation

```bash

# 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

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

```

## Configuration Examples

### Default Safe Profile (Auto-Cache)

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

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

```

### Kernel Cache Profile (Unsafe, Maximum Read Speed)

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

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

```

### Programmatic Benchmark Execution

```ts
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)](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)](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)](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)](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)](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)](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.