memory management

Resizing RAM Disk in Linux (/dev/shm): A Quick Guide

April 28, 2010 By Michael Helm in Blog Tags: /dev/shm, /etc/fstab, Linux, Linux filesystem, memory management, RAM disk, server optimization, System Administration, system performance, tmpfs

Linux includes a powerful feature that many system administrators find incredibly useful: a built-in RAM disk, also known as temporary filesystem or tmpfs. This feature allocates a portion of your system’s RAM for temporary storage, providing exceptionally fast read/write operations for applications that benefit from rapid access to temporary files.

Understanding the Default Configuration

By default, Linux allocates 50% of your system’s available RAM to the tmpfs mounted at /dev/shm. This standard allocation strikes a balance between providing ample space for applications that utilize tmpfs while leaving sufficient memory for other system processes.

Don’t worry about “wasting” memory—Linux’s memory management is efficient. If the RAM disk space isn’t being used, the system automatically reallocates that memory to other processes as needed. This dynamic memory management ensures optimal resource utilization regardless of your tmpfs size configuration.

When to Adjust the Default Size

There are several scenarios where modifying the default 50% allocation makes sense:

Resource-intensive applications: Some applications, particularly databases with heavy temporary table usage, may benefit from a larger tmpfs allocation
Systems with large RAM: On servers with substantial memory (e.g., 64GB+), 50% might be excessive for tmpfs needs
Memory-constrained environments: In systems with limited RAM, you might want to reduce the tmpfs size to prioritize memory for critical applications
Specific workloads: Certain workloads with predictable temporary storage needs might benefit from precise tmpfs sizing

How to Modify the RAM Disk Size

The process for adjusting your tmpfs size is straightforward and involves editing the /etc/fstab file.

Step 1: Check the Current Configuration

A default entry in your /etc/fstab file for the RAM disk typically looks like this:

tmpfs                   /dev/shm        tmpfs   defaults        0 0

This configuration uses the system’s default settings, which allocate 50% of available RAM to the tmpfs mount.

Step 2: Modify the Configuration

To change the allocation to a different percentage (for example, 75%), edit the /etc/fstab file and modify the entry to:

tmpfs                   /dev/shm        tmpfs   size=75%        0 0

You can also specify an absolute size instead of a percentage:

tmpfs                   /dev/shm        tmpfs   size=8G         0 0

This would set a fixed size of 8 gigabytes for the RAM disk, regardless of your total system memory.

Step 3: Apply the New Configuration

After modifying the /etc/fstab file, you have two options to apply the changes:

Reboot the system (recommended for production environments to ensure all services properly recognize the new configuration)
Remount the filesystem without rebooting: First, unmount the tmpfs:
```
umount tmpfs
```
Then remount it with the new settings:
```
mount tmpfs
```

Verifying the Changes

To confirm that your changes have been successfully applied, you can check the current mount settings:

bash
df -h /dev/shm

This command will display the size of your RAM disk with the new allocation.

Best Practices

Monitor usage: After resizing, monitor the actual usage of your RAM disk to ensure you’ve allocated an appropriate amount
Document changes: Always document size changes in your system documentation for future reference
Consider workload patterns: Size your RAM disk based on observed workload patterns rather than arbitrary values
Leave room for growth: If sizing by absolute value rather than percentage, consider future memory needs

Conclusion

The ability to resize Linux’s built-in RAM disk provides system administrators with flexibility in optimizing memory allocation for specific workloads. Whether you need to increase the size for performance-critical temporary operations or decrease it to prioritize memory for other applications, the process is straightforward and can be accomplished with minimal downtime.

By understanding and properly configuring the tmpfs mounted at /dev/shm, you can significantly enhance the performance of applications that rely on fast temporary storage while maintaining efficient memory utilization across your system.

Adding a New Swap Partition in Linux: Step-by-Step Guide

July 5, 2009 By Michael Helm in Blog Tags: disk partitioning, fstab, Linux, Linux commands, memory management, parted, server management, swap partition, System Administration, system performance

Following my previous post on creating a swap file, I realized it would be worthwhile to discuss another approach: adding an entirely new swap partition. While swap files are excellent for emergency situations, a dedicated swap partition often provides better performance for long-term use.

Prerequisites

Before we begin, you’ll need:

A separate hard drive that is either not currently mounted or can be safely unmounted using the standard umount command
Root/sudo access to your system

For this guide, I’ll assume the device is /dev/sdc, but your system might use a different device name (such as /dev/sdb, /dev/sda, /dev/hda1, etc.).

Step-by-Step Process

Ensure the drive is unmounted If the drive already contains a swap partition that’s in use, disable it first:
```
swapoff /dev/sdc
```
If the drive is clean and doesn’t have any swap partitions, you can skip this step.
Access the partition manager Launch the parted utility to manage the disk partitioning:
```
parted /dev/sdc
```
This will load the parted prompt, which provides an interface for manipulating disk partitions.
View existing partitions At the parted prompt, enter:
```
print
```
This will display details of any existing partitions and available free space on the disk.
Create the new swap partition Once you’ve identified how much space you want to allocate (at minimum, I recommend matching your RAM size), create the partition with:
```
mkpartfs part-type linux-swap start end
```
Replace start and end with appropriate values shown from the print command. For example, if the starting point is 1024MB and you want a 4GB swap partition, your end point would be 5120MB (1024 + 4096).
Exit parted Type quit to exit the parted utility. The new partition will have been assigned a number, such as sdc2 (or higher if other partitions already exist).
Format the new partition for swap Format the newly created partition as swap space:
```
mkswap /dev/sdc2
```
(Remember to replace sdc2 with your actual partition name)
Activate the swap partition Enable the swap partition with:
```
swapon /dev/sdc2
```

Making the Change Permanent

If you want the system to automatically use this swap partition on every boot, you need to add it to the file system table:

Edit the fstab file
```
vi /etc/fstab
```
Add the swap entry Press Insert to enter edit mode, then add this line to the bottom of the file:
```
/dev/sdc2 swap swap defaults 0 0
```
Save and exit Press Escape, then type :wq or press Shift+Z twice to save and quit.

Verifying the New Swap Space

To confirm that your new swap partition has been successfully added and is active, you can check the system’s swap status:

cat /proc/swaps

This will display all active swap spaces on your system, including your newly created partition.

Final Thoughts

Adding a dedicated swap partition is generally considered a more efficient long-term solution than using a swap file, especially for systems that regularly require swap space. The performance difference is modest on modern systems, but can be noticeable under heavy load.

Remember that while swap space is important for system stability, it’s not a replacement for adequate RAM. If your system is consistently using large amounts of swap space, consider upgrading your physical memory for better performance.

Adding Swap Space Without a Partition in Linux: A Quick Emergency Fix

July 1, 2009 By Michael Helm in Blog Tags: Linux, Linux commands, memory management, server management, server stability, server troubleshooting, swap file, swap space, System Administration, system resources

Recently, we encountered a challenging issue on one of the servers I help administer. The server would occasionally max out its RAM usage, forcing it to rely on swap space. When both RAM and swap space were exhausted, the server would grind to a halt, requiring a manual restart.

The Problem: Growing Needs, Limited Resources

The server in question had been in operation for several years, starting with modest traffic but gradually growing as the websites it hosted gained popularity and their databases expanded. Despite this growth, it was still running with only 512MB of RAM—a limitation we’ve since addressed with an upgrade.

However, we needed an immediate solution before the hardware upgrade could be implemented. The server already had a swap partition, but creating another one wasn’t feasible without significant downtime, as all available hard drives were in active use.

The Solution: Adding a Swap File

The answer turned out to be creating a swap file rather than a swap partition. This approach allows you to add additional swap space without reconfiguring your disk partitions—perfect for an emergency fix. Here’s how to do it:

Navigate to a directory with plenty of available space:
```
cd /home
```
Create a swap file using /dev/zero:
```
bash
dd if=/dev/zero of=swapfile bs=1024 count=4194304
```
This creates an empty file called “swapfile” with a block size of 1024 bytes and 4,194,304 blocks, resulting in a 4GB file. (To calculate the size in GB: 4,194,304 ÷ 1024 ÷ 1024 = 4GB)
Set appropriate permissions on the file:
```
chmod 600 swapfile
```
Format the file as swap space:
```
mkswap swapfile
```
Activate the swap file:
```
swapon swapfile
```

To verify that your new swap space is active, you can run:

cat /proc/swaps

This command displays all active swap spaces on your system, and you should now see your newly created swap file listed alongside any existing swap partitions.

Important Considerations

This solution doesn’t automatically activate on system boot, which was fine for our purposes since we planned to upgrade the RAM soon. If you need a more permanent solution, you would need to add an entry to your /etc/fstab file.

Remember that while this approach can prevent system crashes, it’s only a temporary workaround. Swap space, especially on a traditional hard drive, is significantly slower than RAM. For optimal performance, it’s always better to address the root cause by:

Upgrading physical RAM
Optimizing your application configurations
Considering server upgrades if necessary

That said, when you need a quick fix to keep a server stable until more permanent solutions can be implemented, adding a swap file is a valuable technique to have in your system administration toolkit.