rtcvb32: Personally? I'd like saving 1Gb for running the OS entirely from RAM, then everything else from the hard drive. Fast speed after you get past the copying to ram stage.
Interestingly, if using Linux, I believe it is technically possible, without having to write code in any language other than shell scripting, to create a system that boots off a disk, copies the OS into RAM after booting, and then unmounts the disk, allowing it to be used during the copying to ram stage. In fact, I can think of two approaches:
1. Use the device mapper. At boot, the initramfs will use the device-mapper to create a mirror (RAID1) between an image file on the disk and a disk image stored in RAM. Then, once the system is loaded (or perhaps while it is loaded, particularly if it's a mulit-core system that can easily multi-task), the mirror is broken, and the on-disk file is removed from the mirror. (Note that the issue with the disk file can be solved by making a snapshot; we are really making a RAID1 setup with a snapshot of an on-disk readonly disk image and a in-memory disk image.)
2. Use btrfs. A btrfs filesystem is created using an on-disk image as a seed, and then adding an in-memory btrfs filesystem (again, this is done in the initramfs), then the seed block device is removed from the btrfs filesystem (which causes the data to automatically be moved to the in-memory device). (If the seed filesystem code turns out to have a bug, the same dm-snapshot trick mentioned above can be used to make the first filesystem writable.) This system has the advantage of allowing the in-memory filesystem to be grown at run-time just by creating a new block device and adding it to the filesystem (doing this for the above system would require some more device-mapper trickery and a filesystem resize tool), and it also allows for things like compression, but it also needs a newer kernel version to be reliable.
(Note that ZFS is not suitable for this purpose, as you can't remove a device from a filesystem after creating it.)
Of course, if all you want to do is run from RAM and don't mind waiting until the entire system is copied, there is a much simpler way of doing this, which some Linux distributions (Tiny Core comes to mind) actually use:
* Just put the entire system into the initramfs image. The kernel will unpack the initramfs image into RAM and execute /init as PID 1. In a typical Linux set-up, this init will just find the root filesystem, mount it, and switch to it, but with a full filesystem here (you might need to symlink /init to /sbin/init), this is unnecessary and the entire system can run from initramfs just fine (once it's unpacked, of course).
Edit: It appears that the trick I mentioned could also be done with bcachefs (using the dm-snapshot trick), but I noe that the filesystem in question is not yet in the mainline Linux kernel.