Save your disk, write files directly into RAM with /dev/shm
60 comments
·June 26, 2025hackyhacky
hiAndrewQuinn
I do mention this offhand in the article: "The existence of /dev/shm is a boon for me mostly because it means I never have to worry about whether /tmp is really RAM-based again."
frollogaston
"virtually every Unix system already has it mounted as a tmpfs by default" might be true if you say Linux instead, but Mac doesn't have /dev/shm
AdieuToLogic
OS-X/macOS supports RAM drives and a script which defines one for use as /private/tmp (which /tmp is symbolically linked to) is:
#!/bin/bash
ramfs_size_mb=1024
mount_point=/private/tmp
counter=0
ramfs_size_sectors=$((${ramfs_size_mb}*2048))
ramdisk_dev=`hdiutil attach -nomount ram://${ramfs_size_sectors}`
while [[ ! -d "/Volumes" ]]
do
sleep 1
counter=$((counter + 1))
if [[ $counter -gt 10 ]]
then
echo "$O: /Volumes never created"
exit 1
fi
done
diskutil eraseVolume HFS+ 'RAM Disk' ${ramdisk_dev} || {
echo "$O: unable to create RAM Disk on: ${ramdisk_dev}"
exit 2
}
umount '/Volumes/RAM Disk'
mkdir -p ${mount_point} 2>/dev/null
mount -o noatime -t hfs ${ramdisk_dev} ${mount_point} || {
echo "$0: unable to mount ${ramdisk_dev} ${mount_point}"
exit 3
}
chown root:wheel ${mount_point}
chmod 1777 ${mount_point}
hiAndrewQuinn
Mea culpa, you're right. I should not have assumed that just because POSIX was mentioned in the orbit of this thing that everyone else had this too.
The article has been corrected.
loeg
I may misremember, but I think it's also common in the BSDs? (Whereas /var/tmp is persisted.)
quotemstr
Now you have to worry about whether you can access /dev/shm. Please encourage people to use supported interfaces instead of random voodoo (anything under /dev that wasn't there in 1995) for day-to-day tasks.
hiAndrewQuinn
/dev/shm is typically world-writable by default:
$ ls -ld /dev/shm
drwxrwxrwt 3 root root 120 Jun 32 02:47 /dev/shm/
wredcoll
This is a ridiculous comment but it did make me curious, when did /dev/shm become a common thing?
My current understanding is kernel 2.6, i.e. 2004.
chrisdeso
This is the first linux "thing" I've understood after a first read on hacker news. Love you all and will give this a whirl.
frollogaston
If I already have /tmp and it's not tmpfs, honestly I'm not gonna bother remapping it.
pkulak
I did this for a while, but writing files to ram can be dangerous, since most things assume unlimited disk space. I noticed that updates would fail on machines that had 16 gigs of ram unless I logged out of my window manager and did it from the TTY. Took quite a long time to realize it was because of all the compiles writing to /tmp. Much easier to just let the SSD get used.
buckle8017
This is why having swap even when you have plenty of memory for normal usage is good.
Swap on an SSD isn't even that slow.
null
pkulak
You know what, your comment actually reminds me that this happened when I also had a bug in my configuration that was causing me to not actually use swap. I assume running out of tmpfs uses swap like anything else? I might give tmpfs another try.
pm2222
Systemd clears /tmp from time to time. Just saying.
bbarnett
A decade ago yes, but these days, SSD wear isn't an issue for desktop users.
ctur
This is an unnecessary optimization, particularly for the article's use case (small files that are read immediately after being written). Just use /tmp. The linux buffer cache is more than performant enough for casual usage and, indeed, most heavy usage too. It's far too easy to clog up memory with forgotten files by defaulting to /dev/shm, for instance, and you potentially also take memory away from the rest of the system until the next reboot.
For the author's purposes, any benefit is just placebo.
There absolutely are times where /dev/shm is what you want, but it requires understanding nuances and tradeoffs (e.g. you are already thinking a lot about the memory management going on, including potentially swap).
Don't use -funroll-loops either.
lxgr
> It's far too easy to clog up memory with forgotten files by defaulting to /dev/shm, for instance, and you potentially also take memory away from the rest of the system until the next reboot.
Aren't both solved by swapping?
Although I suppose on Linux, neither having swap, nor it being backed by dynamically growing files, is guaranteed.
hiAndrewQuinn
It's true that with small files, my primary interest is simply not to wear on my disk unnecessarily. However I do also often do work on large files, usually local data processing work.
"This optimization [of putting files directly into RAM instead of trusting the buffers] is unnecessary" was an interesting claim, so I decided to put it to the test with `time`.
$ # Drop any disk caches first.
$ sudo sh -c 'sync; echo 3 > /proc/sys/vm/drop_caches'
$
$ # Read a 3.5 GB JSON Lines file from disk.
$ time wc -l /home/andrew/Downloads/kaikki.org-dictionary-Finnish.jsonl
255111 /home/andrew/Downloads/kaikki.org-dictionary-Finnish.jsonl
real 0m2.249s
user 0m0.048s
sys 0m0.809s
$ # Now with caching.
$ time wc -l /dev/shm/kaikki.org-dictionary-Finnish.jsonl
255111 /dev/shm/kaikki.org-dictionary-Finnish.jsonl
real 0m0.528s
user 0m0.028s
sys 0m0.500s
$
$ # Drop caches again, just to be certain.
$ sudo sh -c 'sync; echo 3 > /proc/sys/vm/drop_caches'
$
$ # Read that same 3.5 GB LSON Lines file from /dev/shm.
$ time wc -l /dev/shm/kaikki.org-dictionary-Finnish.jsonl
255111 /dev/shm/kaikki.org-dictionary-Finnish.jsonl
real 0m0.453s
user 0m0.049s
sys 0m0.404s
I'll probably come back to this and run more tests with some of the more complex `jq` query stuff I have to see if we stay at that 20% mark, or if it gets faster or slower.
AdieuToLogic
A couple things to consider when benchmarking RAM file I/O verses disk-based file system I/O.
1 - Programs such as wc (or jq) do sequential reads, which benefit from file systems optimistically prefetching contents in order to reduce read delays.
2 - Check to see if file access time tracking is enabled for the disk-based file system (see mount(8)). This may explain some of the 20% difference.
zajio1am
Hard disagree. Disk buffer cache is too eager on writes (which makes sense for the usual case), so temporary data written to a filesystem are almost always written to the medium. With several GBs of temporary data it easily could fill up internal SSD write buffers and make whole system choppy.
My use case is to use yt-dlp to download videos to ramfs, watch them and then delete. Before i switched to ramfs, the final pass of yt-dlp (where audio and video tracks are merged to one file) ordinarily caused the issue with choppy system.
chaps
This isn't great advice because /tmp is not always mounted as tmpfs.
I've used /dev/shm extensively for large datasets and it's consistently been a massive speed improvement. Not sure what you're talking about.
quotemstr
> This isn't great advice because /tmp is not always mounted as tmpfs.
Well, complain to whoever's mounting it wrong to fix it.
chaps
Not sure your aggression is warranted, friend. Many distros over the years have had tmpfs mounted and many distros over the years haven't.
Some hosts should have tmpfs mounted and some shouldn't. For those that don't, I can just /dev/shm. This isn't a "right" or "wrong" sorta thing.
molticrystal
For those interested in a windows equivalent, with bells and whistles, ImDisk [0] has a nice ramdisk creation utility with options such as allocating memory dynamically, ntfs compression, and more.
For the more venturous there is GPURamDrive [1] , not as many options, as it was made as a more of an experiment, but with gpu's adding more and more vram, why not?
Jhsto
Speaking of RAM and disks, does anyone know what happens if you structure LVM volume such that there is a RAM based tmpfs as a front cache? Consistency issues aside, could it increase performance? Suppose I have an application that behaves such that it has very IO heavy write buffer of around 100GB with 10x or so NVMe backed storage for more rarely used data. Would you do something else? The main problem I have currently is that the NVMes overheat occasionally from high IOPS which adds a lot of latency variance.
Waterluvian
An assumption I’ve been revisiting is if I really do need to be writing to disk all the time. I can’t remember the last time I actually had a crash or other event where I would have abruptly lost my work.
I’m wondering if I can completely hide away the detail where I can work exclusively in memory (even when I habitually save my code) and “reconcile” as some task I do before shutdown.
In fact, that doesn’t even feel necessary… I git push my day’s work a number of times. None of that needs a local disk. And 64GB of memory was surprisingly affordable.
hiAndrewQuinn
You might be interested in Tiny Core Linux [0], then, especially piCore. After the initial read from the persistent media, everything is in RAM, the entire filesystem. You are working exclusively in memory until and unless you run a specific command to save everything you care to save back to that media again.
I have it running on a Raspberry Pi so that my already sparingly-used SD card's lifespan gets extended to, hopefully, several years. I have never seen the green writing LED light blink on without me specifically triggering it.
I primarily use it as a cronslave [1]. It has ~50 separate cronjobs on it by now, all wheedling away at various things I want to make happen for free on a clock. But if you live out of a terminal and could spend your days happily inside tmux + vim or emacs -nw, there's nothing stopping you from just doing this. Feels a lot like driving stick shift.
[0]: http://tinycorelinux.net/
[1]: https://hiandrewquinn.github.io/til-site/posts/consider-the-...
johnmaguire
I have a few systemd timers but not nearly 50! Any interesting use cases?
Jhsto
I've been running my daily development laptop on 64GB of RAM for 1,5 years. My anecdotal experience is that no, you don't need persistent storage for most things. In fact, often it's in your way -- it clutters the system over time by causing configuration errors and weird undefined program states. When you can just reboot and all works again it's great. Never going back.
pm2222
64g ram here as well I mount chromium/firefox cache dir as tmpfs
slt2021
I use jupyter notebooks for similar purpose, with the Python kernel's memory keeping the state I want for some random stuff, and notebook being a recipe how to reproduce the calculation/processing.
some of my kernels been running for weeks, as I come back and redo or rework some processing.
the neat thing about jupyter notebooks, is you can interleave python one-liners with bash one-liners and mix them as you wish.
kylecazar
It appears to have been removed
pizlonator
The reason why this might be a bad idea is that /dev/shm is used for shm_open(3).
So in theory some program might pass a name to shm_open that collides with whatever you put in /dev/shm.
Unlikely but possible
layer8
How is that different from two unrelated programs using shm_open with conflicting file names? Such programs need to ensure unique names anyway.
hacker_homie
Just mount tmpfs where you have frequent writes.
ryoshu
I remember using a RAM disk on the IBM PCjr.
kvemkon
And Stacker for D:
cyberge99
Emm386.sys
thedougd
Slap a side car on there for another 512k RAM.
quotemstr
This is what /tmp IS FOR. No need to be clever.
1970-01-01
I think Debian still uses disk space for files in /tmp. YMMV.
necheffa
This will change starting with Trixie.
Of course, I have always manually configured tmpfs for /tmp/ since Jessie as part of my post-install checklist.
frollogaston
/tmp is for temporary files, that's all. It's not about the storage medium.
Rather than re-write your scripts to store temp files into /dev/shm, you can just mount /tmp using the tmpfs file system and get the same benefit for all your programs. Some distros do this by default.
The relevant line from fstab is:
Now any program that writes to /tmp will be writing to a RAM disk, thus sparing unnecessary wear on my SSD.