Portage TMPDIR on tmpfs

When emerging packages it is possible to build them in tmpfs (RAM) space instead of having build files pushed and pulled to Hard Disk Drive (HDD) or Solid State Drive (SSD) space. Building in tmpfs both speeds up emerge times and reduces HDD/SSD wear. For system's containing SSDs, it is generally a good idea to have Portage compile using tmpfs (RAM) instead burning up precious SSD write cycles (especially on something like compiling software).

Generally speaking, unless the system has a large amount of RAM, it may be more of a hassle to setup Portage in tmpfs. Larger packages such as (see below) will fail on only 2 GBs of tmpfs. Keep this in mind when proceeding!

Considering tmpfs' size
The system's tmpfs space should be large enough to handle the largest packages to be compiled on the system. If the tmpfs space were to ever become completely full then the emerge will fail. Most packages would not need more than 1 GB for compilation, but there are a few that are very large and would need more. Those still wanting to compile these packages on tmpfs should verify enough free tmpfs space exists. The following list are estimates on how much space would be allocated on each package. Some of these are based on the minimum space requirements specified on the ebuilds themselves. Note that the actual allocated size may vary depending on the features included when building the package. It should also vary on every version update.

When using to assist in resuming compiles, it should be noted an equal size of the  and  directories is necessary. Alternatively the per-package choices as shown below for large packages requiring large amounts of space can be implemented.

creates a directory in to store compiled elements for resuming. This is why if is a tmpfs it must be of size similar to that of  if a amount of system RAM is to be used in this way.

fstab
Mount Portage's TMPDIR to tmpfs by adding the following to the system's config file:

Adjust the  parameter  to the desired amount of RAM. Systems with large amounts of RAM can increase the number quite significantly.

After has been modified, mount Portage's TMPDIR to RAM by running the  command followed by the directory location outline in :

In the unlikely event that the entire directory is already mounted as tmpfs, it can be worked around by the special   mount option:

Per-package choices at compile time
Portage can be configured to build large packages outside of the tmpfs space on a per-package basis.

Create a file to tell Portage where to place the temporary files directory:

Create a separate temporary file directory outside of the tmpfs mount location:

Create a special Portage file called /etc/portage/package.env in /etc/portage and list all the packages that are too large to be compiled using tmpfs:

Resizing tmpfs
To resize the current tmpfs instance in, run:

Where  is in the form of bytes. It can also be suffixed with,  , or   to respectively have the form of (k)ilobytes, (m)egabytes or (g)igabytes. It can also be suffixed with a  to limit the tmpfs instance to the percentage of current physical RAM, the default being 50% when the parameter is not specified.

The resized tmpfs will not persist to the next boot unless the  parameter is modified in. This is not necessary since a larger tmpfs is only needed during large package compilations.

It is recommended to leave-out at least 1 GB of space for the system to prevent out-of-memory problems. Using swap-disks for some heavy compile-time and link-time instances which are unexpected may also be helpful. Now even if swap-disks are used, reads and writes to it would only be minimal compared to having a physical filesystem behind.

Here is a note about the size parameter in Linux kernel's documentation which can be found in as long as a kernel has been emerged:

Besides the obvious danger of choking the system by allocating too much memory for tmpfs space, it should be generally safe to enlarge the tmpfs during an emerge as this would only increase the size limit of the tmpfs without destroying any data from the emerge process.

For example, if a system has 12 GB of RAM and 3 disks with 2 GB of swap space working in parallel on each disk, then it would be pretty safe to choose size limit equal to. 16 GB size is usually enough to compile Libreoffice and Chromium in parallel (usual ) while reading Internet in a web browser.

It's not often that you'll ever have to do it and would tell you that tmpfs is too small however there are instances that the package's ebuild would be not accurate at estimating the amount of disk space necessary for building the package. Newer packages may end up allocating more space, whereas using lesser USE flags would make it allocate less.

The solution for this is to either enlarge tmpfs, or add the exception to, and then run again.

Save an emerge and resume later
Example: emerging webkit-gtk can take a long time. I want to reboot into another OS and resume this ebuild later.

Optional: I use to inspect the current emerge session. I like using it to remind me of the ebuild version number or hopefully to get an estimated time remaining.

Press + to quit the current session.

Since I am rebooting, I'll have to use or  to save  while preserving permissions. Otherwise the tmpfs contents will be lost; You may want to inspect the memory size of by using :

Reboot, do other stuff, come back later.

Restore.

Resume the ebuild with :

If you're using other repository sources besides  like layman overlays, make sure that you're using the correct repository directory of the ebuild as one package can also belong to other repositories and be chosen to be installed over the one in. You can get the repository name of the current package by reading the last action entry in or reading the build.log file in the package's build directory with a command like.

Do not use the file found in  as it seems to be only a reference. Perhaps there's a way to use it, but one would have to thoroughly understand how and  work.

Happy hacking!

No space left on device
If you encounter a not-enough space error or anything similar, there are basically two things to do:


 * 1) Check the  directory for old package directories from previously failed compiles. Any packages found therein should be deleted; with exceptions made for any failed packages the user would like to resume compiling later.
 * 2) Resize the tmpfs.
 * 3) In case you still get messages related to exhausted disk space during emerge, even though the allocated tmpfs size is not nearly exceeded (check with  during emerge), you may have stumbled upon an inodes shortage. So far it definitely may be a problem for the  package, for it's grand storage requirements, but can be expected for other large packages as well. To workaround - append   to the list of your options for the tmpfs mount in the  file. For additional information refer to 'tmpfs' section in.

As last instance, add a (temporary) swap file somewhere on your system with enough capacity:

This will create the file with  filled with zeroes.

Set up the swap area using:

Enable the file for swapping:

Check, if the swap file is active:

Compile the packages which would dead lock the computer because of high RAM usage.

Alternatively, remove the swap file when finished: