RAM File System benchmarks: methodology and how to reproduce
This page documents exactly how we measured the numbers on the RAM File System product page and in the RAM Disk comparison. Everything here was run on a single computer in one session, using standard tools, so you can repeat it yourself.
Test machine
| Component | Details |
|---|---|
| Processor | Intel Core i9-13900KS |
| Memory | 96 GB DDR5 |
| Operating system | Windows 11 24H2 |
| RAM FS volume | 64 GB |
| RAM Disk volume | 64 GB NTFS |
| SSD | Samsung 990 PRO NTFS |
Conditions
- Same machine, same session. All three targets were tested back-to-back on the identical hardware, so the only variable is the storage.
- Windows Defender real-time protection was off. It otherwise intercepts file operations and adds noise that is not part of the storage itself.
- Best of a few runs for the timed tasks, to remove one-off outliers.
Synthetic throughput and IOPS (DiskSpd)
We used DiskSpd, the same engine CrystalDiskMark runs on, with the flags CrystalDiskMark uses. The key flag is -S, which disables the operating system cache so the numbers reflect the storage itself. Swapping -S for -Sb repeats the test through the cache (the buffered path that ordinary programs use).
A 1 GiB test file was created first, then each pattern was measured:
diskspd -b1024K -o8 -t4 -W0 -S -w0 -si -ag -d5 -L R:\test.dat
:: random 4 KiB reads, one at a time, single thread
diskspd -b4K -o1 -t1 -W0 -S -w0 -r -ag -d5 -L R:\test.dat
:: random 4 KiB writes, queue depth 32, 4 threads
diskspd -b4K -o32 -t4 -W0 -S -w100 -r -Z4K -ag -d5 -L R:\test.dat
The tables below give throughput for each target, then how far ahead RAM FS is against the RAM Disk and against the SSD. A positive figure means RAM FS is faster.
Unbuffered, single thread, GB/s
| Scenario | SSD | RAM Disk | RAM FS | vs RAM Disk | vs SSD |
|---|---|---|---|---|---|
| SEQ 1M, QD8, read | 7.1 | 47.4 | 50.4 | +6% | +611% |
| SEQ 1M, QD8, write | 5.4 | 61.7 | 68.6 | +11% | +1162% |
| SEQ 1M, QD1, read | 2.7 | 13.4 | 20.1 | +50% | +634% |
| SEQ 1M, QD1, write | 4.3 | 23.2 | 43.4 | +87% | +906% |
| RND 4K, QD32, read | 0.7 | 1.9 | 3.8 | +98% | +460% |
| RND 4K, QD32, write | 1.0 | 1.8 | 3.3 | +83% | +239% |
| RND 4K, QD1, read | 0.1 | 2.0 | 4.7 | +129% | +9012% |
| RND 4K, QD1, write | 0.1 | 1.9 | 3.9 | +110% | +3143% |
Unbuffered, four threads, GB/s
| Scenario | SSD | RAM Disk | RAM FS | vs RAM Disk | vs SSD |
|---|---|---|---|---|---|
| SEQ 1M, QD8, read | 7.1 | 45.0 | 73.4 | +63% | +929% |
| SEQ 1M, QD8, write | 6.5 | 68.8 | 68.2 | -1% | +950% |
| SEQ 1M, QD1, read | 7.1 | 44.1 | 37.4 | -15% | +425% |
| SEQ 1M, QD1, write | 4.6 | 48.2 | 62.8 | +30% | +1270% |
| RND 4K, QD32, read | 1.8 | 4.5 | 9.6 | +111% | +421% |
| RND 4K, QD32, write | 2.6 | 4.0 | 8.1 | +103% | +212% |
| RND 4K, QD1, read | 0.2 | 5.0 | 11.1 | +123% | +4796% |
| RND 4K, QD1, write | 0.7 | 4.3 | 9.1 | +113% | +1155% |
In a couple of tests RAM Disk wins at four threads: bulk sequential writes are a tie, and one low-queue sequential read is a little behind. We show every number rather than a hand-picked few. Everywhere else RAM FS leads, and against the SSD it leads by a wide margin, especially on small random reads taken one at a time, where the SSD is held to about 12500 operations per second by its latency while RAM FS answers over a million.
Buffered, single thread, GB/s
| Scenario | SSD | RAM Disk | RAM FS | vs RAM Disk | vs SSD |
|---|---|---|---|---|---|
| SEQ 1M, QD8, read | 8.0 | 7.8 | 49.4 | +533% | +516% |
| SEQ 1M, QD8, write | 6.7 | 6.7 | 68.1 | +918% | +923% |
| SEQ 1M, QD1, read | 8.5 | 8.2 | 19.5 | +138% | +131% |
| SEQ 1M, QD1, write | 6.5 | 6.5 | 42.7 | +558% | +558% |
| RND 4K, QD32, read | 1.4 | 1.4 | 2.8 | +98% | +98% |
| RND 4K, QD32, write | 1.3 | 1.3 | 3.4 | +172% | +174% |
| RND 4K, QD1, read | 1.7 | 1.6 | 3.1 | +92% | +83% |
| RND 4K, QD1, write | 1.5 | 1.6 | 4.1 | +160% | +166% |
Buffered, four threads, GB/s
| Scenario | SSD | RAM Disk | RAM FS | vs RAM Disk | vs SSD |
|---|---|---|---|---|---|
| SEQ 1M, QD8, read | 13.7 | 14.1 | 71.4 | +407% | +420% |
| SEQ 1M, QD8, write | 12.0 | 12.2 | 70.0 | +472% | +484% |
| SEQ 1M, QD1, read | 16.2 | 16.7 | 37.0 | +122% | +128% |
| SEQ 1M, QD1, write | 12.1 | 12.5 | 60.8 | +387% | +404% |
| RND 4K, QD32, read | 2.3 | 2.3 | 7.0 | +211% | +207% |
| RND 4K, QD32, write | 2.1 | 2.1 | 9.2 | +340% | +339% |
| RND 4K, QD1, read | 2.5 | 2.4 | 7.9 | +229% | +221% |
| RND 4K, QD1, write | 2.2 | 2.2 | 10.3 | +373% | +370% |
Buffered is the way ordinary applications read and write. Here the SSD and the RAM Disk are almost equal, because both are served by the Windows file cache rather than by the device, which is why the vs RAM Disk and vs SSD figures are nearly identical. RAM FS does not use that cache and serves files straight from memory, so it stays several times ahead of both.
Real-world tasks
These use everyday tools, timed with a stopwatch. The archive is a 7z of the full Apple open source collection (apple-oss-distributions), a source tree of 649000 files, about 10 GB unpacked. Times in seconds, lower is better.
Extract, delete and copy a large tree
7z x macos-src.7z -oR:\tree -y
:: copy the tree (32 parallel threads)
robocopy R:\tree R:\copy /E /MT:32
:: delete the tree
rd /s /q R:\tree
| Task | SSD | RAM Disk | RAM FS |
|---|---|---|---|
| Extract 649,000 files | 144.8 s | 101.0 s | 59.8 s |
| Copy the tree, 32 threads | 69.9 s | 37.1 s | 7.4 s |
| Delete the tree | 39.2 s | 17.2 s | 6.7 s |
What ties, and why
Work limited by the processor rather than by storage finishes in about the same time on all three targets. Compiling code is the obvious example: the bottleneck is the CPU, not the disk. That is worth stating plainly: RAM FS helps wherever storage is the critical point. When instead the processor is the limit, there is little left for faster storage to improve.
That said, a build is still worth pointing at RAM FS even when the clock barely moves. Compilers and linkers produce a great many short-lived intermediate files, and keeping those in memory spares your SSD the constant writing and deleting. That prolongs the drive's life and keeps the clutter of temporary files off your permanent storage.