Authors Top

If you have a few years of experience in the Linux ecosystem, and you’re interested in sharing that experience with the community, have a look at our Contribution Guidelines.

1. Overview

Sometimes, we might need to check for total memory size on a server running Linux or we might need to use memory stats in shell scripts. Fortunately, we have access to numerous tools that we can use to check for total physical memory. In this tutorial, we’re going to take different approaches to serve that purpose by using several useful commands and tools.

2. free Command

free is the simplest of all the commands we’ll see. It’s used to print the physical and swap memory usage — by default, it prints to standard output. The free command is one of the widely used commands to quickly check for RAM stats because it’s available on most Linux distributions. We can simply type the free command on our terminal without any flags:

$ free
               total        used        free      shared  buff/cache   available
Mem:         8021048     1320432     5689744      335556     1010872     6121932
Swap:              0           0           0

As we can, the size of the physical memory is printed in bytes. However, we can easily print the output in a human-readable format using the -h or –human flag:

$ free -h
               total        used        free      shared  buff/cache   available
Mem:           7.6Gi       1.3Gi       5.4Gi       318Mi       985Mi       5.8Gi
Swap:             0B          0B          0B

As can be seen in the output above, we have a total of 7.6 GiB of RAM. Moreover, there are lots of other options that can be used to print the output in the format we like such as –kilo–mega–Giga, and so on. One more interesting option is the -s option:

$ free -h -s 5

The -s flag stands for seconds, so free will print the RAM usage every 5 seconds in this example. It’s especially useful if we want to monitor the RAM usage at a specified interval. We can easily terminate the process with Ctrl + C keyboard shortcut.

3. vmstat Command

Like the free command, vmstat (virtual memory statistics) is also available on most Linux distributions. By default, when we type the vmstat command, it will print the free, buffered, and cached memory alongside swap, CPU, IO, and system information:

$ vmstat -w
--procs-- -----------------------memory---------------------- ---swap-- -----io---- -system-- --------cpu--------
   r    b         swpd         free         buff        cache   si   so    bi    bo   in   cs  us  sy  id  wa  st
   1    0            0      5352900        56816      1053708    0    0   162    73  328 1087  18   4  78   0   0

The -w or –wide flag prints the output in a wide readable format. Since we’re interested in total RAM size, we’re going to add the -s or –stats flag:

$ vmstat -s
      8021048 K total memory
      1564516 K used memory
       305336 K active memory
      1962636 K inactive memory
      5391588 K free memory
        58224 K buffer memory
      1006720 K swap cache
            0 K total swap
            0 K used swap
            0 K free swap
        76393 non-nice user cpu ticks
            5 nice user cpu ticks
        14122 system cpu ticks
       337834 idle cpu ticks
         1790 IO-wait cpu ticks
         1463 IRQ cpu ticks
          614 softirq cpu ticks
            0 stolen cpu ticks
       617253 pages paged in
       310410 pages paged out
            0 pages swapped in
            0 pages swapped out
      1426200 interrupts
      4722588 CPU context switches
   1625563254 boot time
         1949 forks

The first entry in the output is total physical RAM. Sometimes, we don’t need all the info, so we can use grep to extract only the desired entry:

$ vmstat -s | grep -i 'total memory' | sed 's/ *//'
8021048 K total memory

4. top Command

top is basically a command-line task manager with a real-time output. It’s used to check the running processes in a clean table layout. It also shows us the CPU, RAM, and system information in general. We can fire it up by simply running the top command:

$ top
top - 15:18:13 up 57 min,  1 user,  load average: 3.40, 3.26, 2.04
Tasks: 138 total,   1 running, 137 sleeping,   0 stopped,   0 zombie
%Cpu(s): 17.2 us,  3.6 sy,  0.0 ni, 77.5 id,  0.3 wa,  0.9 hi,  0.5 si,  0.0 st
MiB Mem :   7833.1 total,   4665.9 free,   1782.3 used,   1384.8 buff/cache
top - 15:18:49 up 57 min,  1 user,  load average: 2.61, 3.08, 2.03
Tasks: 138 total,   1 running, 137 sleeping,   0 stopped,   0 zombie
top - 15:18:58 up 58 min,  1 user,  load average: 2.45, 3.02, 2.02
MiB Swap:      0.0 total,      0.0 free,      0.0 used.   5324.5 avail Mem

At the top, we can see the memory information beside the Mem field and observe that we have a total of 7833 MiB of total RAM.

5. dmidecode Utility

dmidecode is a helper tool that prints information about hardware components – such as hardware specifications, serial numbers, and BIOS versions – in a human-readable format. The hardware information is extracted from the DMI table. We can also use it to find interesting information about our system such as the maximum supported memory.

5.1. Installing dmidecode

dmidecode is not installed on some Linux distributions by default, so we’re going to install it first. We can install dmidecode directly from our distribution repository using a package manager.

For Ubuntu-based distributions, we can install the package through apt:

# apt install dmidecode

For RHEL, Fedora, and CentOS, we can use yum:

# yum install dmidecode

On Arch-based distributions, simply use pacman:

# pacman -Sy dmidecode

5.2. Using dmidecode

Once the installation is complete, we can run the dmidecode command from our terminal:

# dmidecode

We need to have root privileges to run dmidecode. Once we run the command, we’ll be able to see detailed hardware information. It contains a lot of information related to our hardware components, but we’re only interested in our total memory size.

Fortunately, we can feed the –type option to the command for different components such as BIOS, memory, processor, temperatures, and so on. The –type option expects a number for DMI types.

In our case, we want to look at the memory DMI type, which can be accessed with the assigned numbers 5, 6, 16, 17, 18, 19, 20, 21, and 22. However, we’re interested in the number 19, which will print the RAM devices that are currently attached to the slots on our motherboard:

# dmidecode --type 19
# dmidecode 3.3
Getting SMBIOS data from sysfs.
SMBIOS 3.0.0 present.

Handle 0x0049, DMI type 19, 31 bytes
Memory Array Mapped Address
	Starting Address: 0x00000000000
	Ending Address: 0x001FFFFFFFF
	Range Size: 8 GB
	Physical Array Handle: 0x0044
	Partition Width: 1

As we can see, we only have a single RAM device with 8 GB of total size installed in one of the RAM slots.

6. /proc/meminfo Virtual File

The /proc directory is a special type of directory that contains virtual files. These virtual files are a way to take a peek at the Linux kernel, processes, and configurations. These files don’t actually exist on the disk and take no space, but they’re created when they are read. Access to some of the files requires root access.

There’s a special virtual file named meminfo, inside the /proc directory, that can be read with commands like cat and less. The meminfo file contains information about our physical memory size among other useful information. Let’s read the /proc/meminfo file using cat:

$ cat /proc/meminfo

In the example above, we’ve used the cat command, which is a useful utility that can read from a file or standard input. Once the command is executed, it will read /proc/meminfo and present us with a long output regarding our physical memory. We’re only interested in the total RAM size, which appears in the top three lines of the output:

$ cat /proc/meminfo | head -n 3
MemTotal:        8021048 kB
MemFree:         4542960 kB
MemAvailable:    5155668 kB

We printed only the lines that we’re interested in by using the head command. The -n argument provided to the head command is used to specify the number of lines to read. The sizes are printed in kilobytes and should give us an idea of what our total, free, and available physical memory is.

Let’s suppose we’re writing a Bash script where we need to process the physical RAM size. We can achieve that by reading the /proc/meminfo file first and then grep the total memory size:

#!/bin/bash

total_ram () {
  local totalram=$(cat /proc/meminfo | grep -i 'memtotal' | grep -o '[[:digit:]]*')
  echo $totalram
}

ram_size=$(total_ram)
echo "Total RAM: $ram_size kB"

Now, let’s save the script and make it executable:

$ chmod +755 totalram.sh
$ ./totalram.sh
Total RAM: 8021048 kB

7. Using GUI Task Managers

There are a variety of GUI task managers that we can use to check for CPU, RAM, and network usage in addition to managing processes. Let’s take a quick look at the most popular ones for Linux.

7.1. GNOME System Monitor

GNOME System Monitor is the default task manager that ships with the GNOME desktop environment. However, if we’re running a different desktop environment, we can easily look for the gnome-system-monitor package on our distribution package repository. Once it’s installed, we can launch it from the command line:

$ gnome-system-monitor

 

Upon navigating to the Resources tab, we can see our total memory size among other stats.

7.2. KSysGuard

KSysGuard is the default task manager developed by the KDE community and comes with KDE by default. Similarly, if we’re using a different desktop environment, we can easily install it on our system by looking for the ksysguard package in the package repository. We can launch it with the ksysguard command once it’s installed:

$ ksysguard

 

Once ksysguard starts, we can head to the System Load tab and see our memory information along with a nice graph.

8. Conclusion

In this article, we looked at different commands and tools that can help us find out the physical memory size of our Linux system.

We covered the minimal free command and its alternative vmstat command. Then we used the top command to find out various system information. We also looked at the dmidecode utility and how we can extract the physical memory information from the DMI table.

Afterward, we learned what the /proc directory is and how we can read the /proc/meminfo file to check for total RAM size and use it in a bash script. Finally, we learned about a couple of graphical task managers and how we can use them to check for RAM usage and stats.

Authors Bottom

If you have a few years of experience in the Linux ecosystem, and you’re interested in sharing that experience with the community, have a look at our Contribution Guidelines.

Comments are closed on this article!