Do I need swap space if I have more than enough amount of RAM?

Question

From what I understand, the purpose of a swap partition in Linux is to free up some "not as frequently accessed" information from RAM and move it to a specific partition on your harddrive (at the cost of making it slower to read from or write to), essentially allowing active applications more of the "high speed memory".

This is great for when you are on a machine with a small amount of RAM and don't want to run into problems if you run out. However, if your system has 16 GB or 32 GB of RAM, and assuming you aren't running a MySQL database for StackExchange or editing a 1080p full length movie in Linux, should a swap partition be used?

Answer 1

Yes.

You should most definitely always have swap enabled, except if there is a very compelling, forbidding reason (like, no disk at all, or only network disk present). Should you have a swap on the order of the often recommended ridiculous sizes (such as, twice the amount of RAM)? Well, no.

The reason is that swap is not only useful when your applications consume more memory than there is physical RAM (actually, in that case, swap is not very useful at all because it seriously impacts performance). The main incentive for swap nowadays is not to magically turn 16GiB of RAM into 32 GiB, but to make more efficient use of the installed, available RAM.

On a modern computer, RAM does not go unused. Unused RAM is something that you could just as well not have bought and saved the money instead. Therefore, anything you load or anything that is otherwise memory-mapped, anything that could possibly be reused by anyone any time later (limited by security constraints) is being cached. Very soon after the machine has booted, all physical RAM will have been used for something.

Whenever you ask for a new memory page from the operating system, the memory manager has to make an educated decision:

1. Purge a page from the buffer cache
2. Purge a page from a mapping (effectively the same as #1, on most systems)
3. Move a page that has not been accessed for a long time -- preferably never -- to swap (this could in fact even happen proactively, not necessarily at the very last moment)
4. Kill your process, or kill a random process (OOM)
5. Kernel panic

Options #4 and #5 are very undesirable and will only happen if the operating system has absolutely no other choice. Options #1 and #2 mean that you throw something away that you will possibly be needing soon again. This negatively impacts performance.

Option #3 means you move something that you (probably) don't need any time soon onto slow storage. That's fine because now something that you do need can use the fast RAM.

By removing option #3, you have effectively limited the operating system to doing either #1 or #2. Reloading a page from disk is the same as reloading it from swap, except having to reload from swap is usually less likely (due to making proper paging decisions).

In other words, by disabling swap you gain nothing, but you limit the operation system's number of useful options in dealing with a memory request. Which might not be, but very possibly may be a disadvantage (and will never be an advantage).

[EDIT]

The careful reader of the mmap manpage, specifically the description of MAP_NORESERVE, will notice another good reason why swap is somewhat of a necessity even on a system with "enough" physical memory:

"When swap space is not reserved one might get SIGSEGV upon a write if no physical memory is available."

-- Wait a moment, what does that mean?

If you map a file, you can access the file's contents directly as if the file was somehow, by magic, in your program's address space. For read-only access, the operating system needs in principle no more than a single page of physical memory which it can repopulate with different data every time you access a different virtual page (for efficiency reasons, that's of course not what is done, but in principle you could access terabytes worth of data with a single page of physical memory). Now what if you also write to a file mapping? In this case, the operating system must have a physical page -- or swap space -- ready for every page written to. There's no other way to keep the data around until the dirty pages writeback process has done its work (which can be several seconds). For this reason, the OS reserves (but doesn't necessarily ever commit) swap space, so in case you are writing to a mapping while there happens to be no physical page unused (that's a quite possible, and normal condition), you're guaranteed that it will still work.

Now what if there is no swap? It means that no swap can be reserved (duh!), and this means that as soon as there are no free physical pages left, and you're writing to a page, you are getting a pleasant surprise in the form of your process receiving a segmentation fault, and probably being killed.

[/EDIT]

However, the traditional recommendation of making swap twice the size of RAM is nonsensical. Although disk space is cheap, it does not make sense to assign that much swap. Wasting something that is cheap is still wasteful, and you absolutely don't want to be continually swapping in and out working sets several hundreds of megabytes (or larger) in size.

There is no single "correct" swap size (there are as many "correct" sizes as there are users and opinions). I usually assign a fixed 512MiB, regardless of RAM size, which works very well for me. The reasoning behind that is that 512MiB is something that you can always afford nowadays, even on a small disk. On the other hand, adding several gigabytes of swap is none better. You are not going to use them, except if something is going seriously wrong.

Even on a SSD, swap is orders of magnitude slower than RAM (due to bus bandwidth and latency), and while it is very acceptable to move something to swap that probably won't be needed again (i.e. you most likely won't be swapping it in again, so your pool of available pages is effectively enlarged for free), if you really need considerable amounts of swap (that is, you have an application that uses e.g. a 50GiB dataset), you're pretty much lost.

Once your computer starts swapping in and out gigabytes worth of pages, everything goes to a crawl. So, for most people (including me) this is not an option, and having that much swap therefore makes no sense.

Answer 2

I'm going to disagree with a few of the opinions that I see stated here. I'd still be creating a SWAP partition especially in a production environment. I do it for my home machines and VMs as well.

These days I'm sizing them around 1-1.5 times memory. 2 times memory used to be the rule of thumb. The swap disk is "cheap" in that it does not need to be backed up or protected.

Should you run low on memory, then your swap space gives you a little time and cushion to address the problem.

Realize that things like /tmp can reside in the swap space.

The swap area can hold a partial kernel dump so that it can be restored on the next reboot. This might be nice for some future debugging emergency that you are called to do.

Answer 3

Maybe:

I've given a lot of thought to this topic and seen opinions landing on both sides of the argument more times than I can count. My approach was to develop a way to find out.

Start with an active swap partition of what you think is a sufficient size.

Then, open a terminal in a workspace and issue the command free -hs 1 which will report usage once every second.

Optionally switch to other workspaces.

Do every thing you are likely to ever do and then some more. Run all your common apps at once, browse multiple tabs and try desperately to give the system a real workout for you this might mean re-encoding a 1/2 dozen videos while running a compile operation and checking your email or whatever. Let's face facts, this is all about how You use your system.

When you feel you have the system under a high load (or as high as your ever likely to get and then some) look at the terminal and examine the results. or better yet redirect output to a file by adding >output.txt to the command so that you can examine the full run. If your Swap used never exceeds Mem free you don't need swap. If it does, you do.

I don't need swap. Maybe you do. Why not find out?

As far as sizing swap is concerned, Rules of thumb are typically over-rated as this is use based question.

Answer 4

NOTE: This happened to me, in a specific, unusual situation. If you are troubleshooting a problem, this might be useful. I do not mean to imply that ALL machines MUST have swap.

MAYBE!

I have run into problems in the past with an "appliance" I built, running Linux - running on a compact flash device, I did not want to wear my CF by using swap, and there was enough memory for the application.

Most of these appliances worked fine, but on a particularly busy box, I ran into a problem:

MEMORY FRAGMENTATION

Without swap space, the memory gradually became more and more fragmented, especially with long running processes (even though I had lots of free memory, it was all in very small bits). I put some swap space in, and told Linux not to use it unless it had to; this solved the problem completely.

In addition to everything else, swap space allows memory to be moved around, defragmenting it. If you have fragmented memory, and you need a single large chunk, the fragments will be swapped out; as they are swapped back in, they are effectively defragmented.

Check out /proc/buddyinfo - mine looks like this right now:

Node 0, zone      DMA      9      5      3      4      2      3      2      2      3      3      1 
Node 0, zone    DMA32  33901   1149      0      0      0      0      0      0      0      0      1 
Node 0, zone   Normal   2414   1632    259     22      3      0      2      0      1      1      0 

The numbers represent blocks of different sizes; each size is half the size of the next block, from 4mb blocks on the left, to 4kb on the right (that is, 4mb, 2mb, 1mb, and so forth). A newly booted machine should have all the blocks on the left, very few on the right (= not fragmented). Remember also that the same amount of memory (e.g. 4mb) will be represented as different numbers across the columns - 1 block in the left-most column, 1024 on the right-most column.

Memory is allocated from the pool that is as far right as possible; e.g. if your program wants 12kb of memory (in one go), it will take it from the 16kb column; the remainder will appear in the 4kb column. If there are no 16kb blocks, then it will take from the 32kb blocks, resulting in a 16kb and a 4kb left over, and so forth.

If there are no memory blocks large enough, AND YOU HAVE SWAP SPACE, then e.g. if you want 16kb of memory, it will find the least-used block of 16kb (which might, e.g. contain a 4kb used block, a 4kb available block, and 2 more used 4kb blocks), move the USED portions only to swap, and allocate the freed memory to the new application.

In the box that crashed, I had hundreds of thousands of 4kb and 8kb blocks, and not much else.

AS FAR AS I CAN TELL (going by the crashed machines!) the kernel will move from memory to swap, and swap to memory, but will never move from memory to memory.

Answer 5

You should never have swap larger than the maximum size you'd be able to tolerate waiting for the kernel to swap in/out; otherwise, you're just creating a new failure mode for your system (becoming unrecoverably bogged down in swapping). Note that, despite modern drives being able to transfer on the order of GB/sec, Linux is typically only able to move swap at rates more along the lines of hundreds of kB, or at best some MB, per second. So huge swap can leave your system unusable for minutes, hours, or even days.

If you have sufficient physical memory for what you're doing, the ideal size for swap is to match it to the amount of "junk data" processes are keeping around but never using. This is probably in the range of a few to a few hundred megabytes. This strategy allows all of your physical memory to be utilized for caching useful information rather than as permanent store for data that will likely never be used again.

If you don't have sufficient physical memory, you need to evaluate whether you can tolerate severe slowdown from heavy swapping. If so, having up to 1-2 GB of swap might make sense, and perhaps up to 4 GB if you have extremely fast drives. But any more than that is just going to make your system's failure modes worse, and you should consider just buying more RAM instead.

Answer 6

A swap partition has significant value above and beyond simply acting as some extra RAM when you run out.

For one, Linux uses as much memory as possible to cache files and IO operations, if you have some swap you may find that more memory goes into caching IO and making it faster (by minimizing disk access and also lowering wear on SSDs) as opposed to holding data which some program has allocated but is only using once every 12 hours which may be the case for some daemons.

In addition, Linux uses an optimistic memory allocation strategy by which it will allow pages to be nominally allocated even if it is not sure it has real memory to fill them. This is more efficient than doing a proper check and map every allocation and usually causes no problems. However, the heuristics which the kernel uses to determine if allowing an allocation is sensible include the level of swap available on the system, therefore allocations may be faster if the system has plenty of swap, even if it is not used much.

These factors together bring me to personally believe that it is better to have some swap on almost every normal system however for large ram sizes I ignore the ram * 2 rule and simply cap my swap at 4-8GB (depending on the size of the disk).

Answer 7

Only if you want to be able to hibernate to swap (This feature is also called "suspend to disk" and involves saving the entire contents of RAM and turning off the power). Typically this is only used on laptops and other mobile devices, so it depends.

Answer 8

There's no universal and clear answer because it depends on a task you're about to perform. If you're about to run DB, HTTP, Virtualization or Cache server you should never enable any kind of swap, regardless of the ram amount you have. If you have a desktop or mixed-task host and you have 16+ Gb of fast RAM - take a look here : zRam

Answer 9

There is no way to tell if you need swap space or not if the only parameter we know is the amount of RAM installed.

In any case, there is a common misconception that having a swap space is negatively affecting system performance. This is incorrect. As long as you have enough RAM, having a swap area whatever its size doesn't hurt performance at all. What affects performance is being short in RAM and effectively using the swap space.

• case 1: If you have no swap space and happen to be out of RAM, the Linux kernel will pick one or more processes which it thinks are good candidates and kill them.

• case 2: If you have a swap space and are out of RAM, the kernel will pick less used memory pages and put them on the swap area to free RAM. This will slow down the system but your applications won't be affected otherwise.

I always prefer case 2, as I feel unconfortable loosing parts or all of my work because the kernel thinks my applications are worth killing. Moreover, with the current size of an average disk being in the TB range, reserving a few percent for swap shouldn't be an issue.

Answer 10

My rule to apply swap in any system is to have the answer for this:

• What is the purpose of the system?
• How much memory will the applications consume?
• Is this a critical system?
• Do I need a temporary disk space for files transfers?
• Predicted growth rate of the applications?

When I get answer for this information I size the system accordingly. In previous years I was doing the rule of thumb from Sun Microsystem. Up to 16 GB twice as much RAM for SWAP, from 16 GB up the same amount. But on the other hand, if you have enough RAM to spare and your apps don't use SWAP forcibly you can omit swap. If you need is just a matter of putting a new disk or lun and configure the SWAP. the rule of Sun applied mostly because on Solaris in case of "kernel panic" the memory would be dumped entirely to swap for further analysis.

Answer 11

The short answer:

Yes, you always need some swap, just in the unlikely the case that an application doesn't even bother mapping memory but maps virtual memory directly.

Set your swap file to:

• RAM+round(sqrt(RAM)) if you use hibernation
• round(sqrt(RAM)) if you don't

Set your swappiness to 10 on a desktop, but not on a server!

The long answer:

In the past:

The rule of thumb in use for the last 25 years has been a minimum of 1xRAM and maximum 2xRAM so that is what you'll see quoted all the time.

That minimum was set back in the stone age when I was a teenager and dinosaurs still roamed the Earth and because RAM was just too expensive and you absolutely needed that swap space to be able to accomplish anything.

The maximum was set at that time because of diminishing returns: it's just too slow to have to swap so much memory as HDD access is a factor of 1000 slower then RAM: good in an emergency, but not really good for everyday use! At the time, when you ran out of swap space, it was time to add more RAM! (which is still true today).

In the present:

1. If you do not use hibernation and your memory is in excess of 1GByte the new rule of thumb is round(sqrt(RAM)) where RAM is obviously your RAM size in GB and sqrt the square root. :-)

2. If you use hibernation, you need to be able to swap the entire amount of RAM+already swapped RAM to disk, thus the formula becomes: RAM+round(sqrt(RAM))

3. The rule of diminishing returns still holds today for the maximum, but unless you test your actual usage, taking 2xRAM is just a waste of disk space, so don't use the maximum Unless you run out of swap space using the other methodologies.

All of these together give you the following table: (last 3 columns denoting swap space)

    RAM   No hibernation    With Hibernation    Maximum
    1GB              1GB                 2GB        2GB
    2GB              1GB                 3GB        4GB
    3GB              2GB                 5GB        6GB
    4GB              2GB                 6GB        8GB
    5GB              2GB                 7GB       10GB
    6GB              2GB                 8GB       12GB
    8GB              3GB                11GB       16GB
   12GB              3GB                15GB       24GB
   16GB              4GB                20GB       32GB
   24GB              5GB                29GB       48GB
   32GB              6GB                38GB       64GB
   64GB              8GB                72GB      128GB
  128GB             11GB               139GB      256GB
  256GB             16GB               272GB      512GB
  512GB             23GB               535GB        1TB
    1TB             32GB                 1TB        2TB
    2TB             46GB                 2TB        4TB
    4TB             64GB                 4TB        8TB
    8TB             91GB                 8TB       16TB

The above is just a rule of thumb; it's not the law of gravity!
You can break this rule (unlike the law of gravity) if your particular use case is different!

Pro tip: Always allocate SWAP at the start of a HDD as the heads need to move less on the inside of the disk.
_{Yes: On SSDs, it doesn't really matter any more where you locate the swap area as they use quantum-tunnelling instead of moving heads and modern SSDs use all of their memory cells (even the unallocated space) to prevent quantum degradation.}

How to test if your usage of swap is different from the "generic" rule:

Just execute:

for szFile in /proc/*/status ; do 
  awk '/VmSwap|Name/{printf $2 "\t" $3}END{ print "" }' $szFile 
done | sort --key 2 --numeric --reverse | more

which will give you a list of all running programs that are swapped out (with the one using the most swap space on top)

If you're using more then a few KB: resize to more then the minimum, otherwise, don't bother...

If you're on a server, stop reading now: you're all set!

---

If you're on a desktop/laptop client (not server), you want your GUI to be as responsive as possible and only swap when you really need to. Ubuntu has been optimised to swap early for server use, but on your client you want editing that huge 250 Mega-pixel raw picture in gimp to be speedy, so setting your swappiness to 10 will keep the kernel from swapping too early, while ensuring it doesn't swap too late:

If you have a sysctl.conf file,

sudo nano /etc/sysctl.conf

OR

If you have a sysctl.d directory but no sysctl.conf file, create a new file:

sudo nano /etc/sysctl.d/35_swap.conf 

and in both cases add:

# change "swappiness" from default 60 to 10 
# (theoretically only swap when RAM usage reaches around 80 or 90 percent)
vm.swappiness = 10

to the end of the file, save the file (Ctrl+XY+Enter in nano) and execute a:

sysctl --system

to reload the parameter or take the Window$ approach and reboot... :-)

Answer 12

Swap will be needed if you don't have enough RAM to run all your programs.

You say you're not doing anything which requires a lot of RAM. So, you do have enough RAM.

Then, you don't need swap space.

But, if you think that at some point, despite what you imply in your question, your programs will use, say more that half (or two thirds) of your RAM (rule of thumb), then please read the other "pro-swap" answers. You will not need swap, but it could enhance your system performance (by allowing your system to make better use of extra RAM, e.g. for caching or buffers).

Answer 13

Compromise answer: it depends on the meaning of "should".

Do you need a swap partition in the sense that something bad will happen if you don't have one under the operating conditions you describe? No.

It is wise to have a swap partition just in case you accidentally spawn an army of memory hogs so you have a chance to kill them before the OOM killer kicks in? Yes.

If your physical RAM "greatly" exceeds the data memory usage of all programs you will run simultaneously at all times, then there is no performance benefit to having swap. If exceeds, but not "greatly", there may be a performance benefit if the OS is able to swap out rarely-used memory to keep more frequently-accessed -file data- in memory.

In summary, it's great that you have 16GB RAM. But, if you also have a 1TB disk, can't you reserve 16GB of it to swap? It's only 1.5% of the disk.