What is virtual memory linux

Linux supports virtual memory , that is, using a disk as an extension of RAM so that the effective size of usable memory grows correspondingly. The kernel will write the contents of a currently unused block of memory to the hard disk so that the memory can be used for another purpose. When the original contents are needed again, they are read back into memory. This is all made completely transparent to the user; programs running under Linux only see the larger amount of memory available and don’t notice that parts of them reside on the disk from time to time. Of course, reading and writing the hard disk is slower (on the order of a thousand times slower) than using real memory, so the programs don’t run as fast. The part of the hard disk that is used as virtual memory is called the swap space .

Linux can use either a normal file in the filesystem or a separate partition for swap space. A swap partition is faster, but it is easier to change the size of a swap file (there’s no need to repartition the whole hard disk, and possibly install everything from scratch). When you know how much swap space you need, you should go for a swap partition, but if you are uncertain, you can use a swap file first, use the system for a while so that you can get a feel for how much swap you need, and then make a swap partition when you’re confident about its size.

You should also know that Linux allows one to use several swap partitions and/or swap files at the same time. This means that if you only occasionally need an unusual amount of swap space, you can set up an extra swap file at such times, instead of keeping the whole amount allocated all the time.

A note on operating system terminology: computer science usually distinguishes between swapping (writing the whole process out to swap space) and paging (writing only fixed size parts, usually a few kilobytes, at a time). Paging is usually more efficient, and that’s what Linux does, but traditional Linux terminology talks about swapping anyway.

Источник

UNIX: top и ps — VIRT, RES, SHR и SWAP память

VIRT (Virtual memory) — отображает общий объём памяти, который может использоваться процессом в данный момент. Включает в себя реально используемую память, другую память (например — память видеокарты), файлы на диске, загруженные в память (например — файлы библиотек), и память, совместно используемую с другими процессами ( SHR или Shared memory ). Она же отображается как VSZ в результатах ps (Process status) .

RES (Resident memory size) — отображает, сколько физической памяти занято процессом (используется для отображения в колонке %MEM в top -е). Она же отображается как RSS в результатах ps (Process status) .

SHR (Shared Memory size) — отображает объём VIRT памяти, который используется процессом совместно с другими процессами, например — файлы библиотек.

SWAP (Swapped size) — память, которая в данный момент не используется (не- RES ), но доступна процессу, при этом она «выгружена» в swap -раздел диска.

o: VIRT — Virtual Image (kb)
The total amount of virtual memory used by the task. It includes all code, data and shared libraries plus pages that have been swapped out. (Note: you can define the STATSIZE=1 environment variable and
the VIRT will be calculated from the /proc/#/state VmSize field.)

p: SWAP — Swapped size (kb)
Per-process swap values are now taken from /proc/#/status VmSwap field.

q: RES — Resident size (kb)
The non-swapped physical memory a task has used.

VSZ (VSS) — Virtual Size in Kbytes (alias vsize) или Virtual memory — особый уровень абстракции «над» архитектурой физической памяти.

Каждый процесс получает в использование виртуальное адресное пространство, и при обращении к адресу в нём — адрес сначала конвертируется в адрес физической памяти (main memory — MM , она же RAM) при помощи Memory Management Unit (MMU) . Данные в виртуальном адресном пространстве могут располагаться в основной памяти, на диске (в swap -файле), сразу в обоих местах или на какой-то внешней памяти (например — памяти видеокарты). Однако, как только процесс запрашивает какие-то данные, которые в настоящий момент не находятся в основной памяти системы — они туда загружаются. Таким образом, процесс не считывает данные напрямую с диска ( memory mapping ), но некоторые или все его ресурсы могут находится на «внешней памяти» в любое время, а его страницы памяти могут быть выгружены в swap, что бы освободить память для других процессов.

RSS — Resident Set Size — количество выеделенной процессу физической ( MM ) памяти в настоящий момент. Это физическая память, которая используется для рамзмещения страниц виртуальной памяти ( virtual memory pages ), которая используется процессом постоянно. RSS всегда будет менее или равна памяти VSZ.

Вообще это очень большая тема, потому — несколько ссылок:

Источник

Linux: типы памяти

Виртуальная память (Virtual Memory)

В современных операционных системах каждый процесс выполняется в собственном выделенном ему участке памяти. Вместо отображения (mapping) адресов памяти непосредственно на физические адреса, операционная система работает как некий абстрактный слой, создавая виртуальное адресное пространство для каждого процесса. Процесс отображение адресов между физической памятью и виртуальной памятью выполняется процессором с использованием «таблицы трансляции» (translation table) (или «таблица страниц«, или «адресная таблица«, «таблица перевода«) для каждого процесса, которая поддерживается ядром системы (каждый раз, когда ядро изменяет процесс, выполняющийся процессором, он изменяет адресная таблицу этого процессора).

Концепция виртуальной памяти имеет несколько целей. Во-первых, она осуществляет изоляцию процессов. Процесс в своём адресном пространстве получает доступ памяти только как к адресам виртуальной памяти. Соответственно, он имеет доступ к данным, которые предварительно были отображены в его собственное виртуальное пространство, и не имеет доступа к памяти других процессов (если память или часть памяти другого процесса не является общей (shared memory)).

Вторая цель — абстракция физической памяти. Ядро может изменять адреса физической памяти, на которую отображена виртуальная память. Кроме того, ядро может вообще не выделять физическую память процессу, пока она действительно не понадобится. Так же, ядро может переместить часть памяти в swap , если она не используется продолжительное время. Всё вместе это даёт большую свободу ядру, и единственным ограничением для него является то, что когда процесс обращается к участку памяти — он должен найти там ту же информацию, которую он записал туда ранее.

Третья цель — возможность выделения адресов объектам, которые ещё не загружены в память. Это основной принцип, лежащий в основе вызова mmap() и отображения файлов в память (file-backend память). Вы можете выделить адрес в памяти для файла, и к нему можно будет обращаться как к любому объекту в памяти. Это очень полезная абстракция, которая помогает упростить код приложений и, в системах х64, и у вас имеется огромное пространство виртуальных адресов, в которое вы можете отобразить хоть всё содержимое вашего жёсткого диска.

Четвёртая цель использования виртуальной памяти — разделение (sharing) памяти для совместного использования процессами. Так как ядро знает, что процесс загружает в память, оно может избежать повторной загрузки объектов, и выделить новые адреса виртуальной памяти для другого процесса, которые будут отображены на те же адреса физической памяти, что и у другого процесса.

Результатом использования «разделяемой памяти» является появление механизма COW (copy-on-write): когда два процесса используют одну и ту же информацию, но один из них изменяет её и при этом второй процесс не имеет доступа на чтение изменившихся данных, ядро выполняет копирование этих данных. Недавно операционная система так же получила возможность определять идентичные данные в разлиных адресах памяти и автоматически отображать их на один и тот же адрес физической памяти. В Linux это называется KSM (Kernel SamePage Merging)

Наиболее часто используемым случаем COW является fork() . В Unix-like системах fork() является системным вызовом, который создаёт новый процесс методом копирования текущего. По кончании выполнения fork() , оба процесса продолжают свою работу с того же состояния, с теми же открытыми файлами и памятью. Благодаря COW, fork() не дублирует всю память процесса, когда «форкает» его, а использует новые адреса памяти только для тех данных, которые изменились родительским или дочерним процессом.

Кроме того, когда вызов fork() создаёт копию («снимок«, snapshot) памяти процесса — он потребляет на это очень мало системных ресурсов. Поэтому, если вы хотите выполнить какие-то операции над памятью процесса без риска потери «почвы под ногами», и при этом вы хотите избежать дорогостоящих (в плане ресурсов системы) действий или каких-то механизмов блокировок, которые могут содержать или приводить к ошибкам — просто используйте fork() , выполните вашу задачу и передайте рузультат её выполнения обратно к родительскому процессу (с помощью кода возврата, файла, через разделяемую память, каналы ( pipe ) и т.д.).

Этот механизм отлично работает, пока результаты выполнения задачи выполняются достаточно быстро, что бы большая часть памяти между родительским и дочерними процессами оставалась разделяемой (общей). Кроме того, это поможет писать более простой и читаемый код, так как все сложные задачи будут скрыты в ядре операционной системы, в коде системы виртуальной памяти, а не в вашем.

Страницы (pages)

Виртуальная память разделена на страницы. Размер одной страницы (прим.: не путайте с блоками (block),которые относятся к данным жесткого диска, тогда как страницы — к памяти) определяется процессором и обычно равен 4 КБ (килобайтам). Это означает, что управление памятью выполняется на уровне страниц, а не битах-байтах и т.д. Когда вы запрашиваете память у системы — ядро выделяет вам одну или более страниц, когда вы особождатете память — вы освобождаете одну или более страниц памяти.

Для каждой выделенной (allocated) страницы ядро устанавливает набор прав доступа (как с обычными файлами в файловой системе) — страница может быть доступна на чтение (readable), запись (writable) и/или выполнение (executable). Эти права доступа устанавливаются либо во время отображения (выделения) памяти, либо с помощью системного вызова mprotect() уже после выделения. Страницы, которые ещё не выделены недоступны. Когда вы попытаетесь выполнить недопустимое действие над страницей памяти (например — считать данные со страницы, у которой не установлено право на чтение) — вы вызовете исключение Segmentation Fault .

Типы памяти (memory types)

Не вся память, выделенная в виртуальном пространстве, одинаковая. Мы можем классифицировать память по двум «осям»: первая — является ли память частной (private), т.е. специфичной для процесса, или общей (shared), и вторая ось — является ли память file-backed или нет (в таком случае — она является «анонимной» (anonymous) памятью). Таким образом — мы можем создать 4 класса памяти:

Источник

Tutorial: Beginners guide on linux memory management

Table of Contents

Linux memory management is a very vast topic and it is not possible to cover all the areas in single article. I will try to give you an overview on major areas and will help you understand important terminologies related to memory management in Linux.

Overview on Linux Memory Management

The central part of the computer is CPU and RAM is the front end portal to CPU
Everything that is going to CPU will go through RAM
For example, if we have a process which is loading, the process will first be loading in RAM and the CPU will get process data from RAM
But to make it faster, the CPU has level one, level two, level three cache. That is like RAM, but on the CPU
There’s very small amounts of cache on the CPU, because it’s very expensive, and it’s also not very useful for all the instructions.
So the process information will be copied from RAM to CPU and the CPU will build its cache.
Here cache plays an important part of memory management on Linux as well.

If a user is requesting information from hard disk, it is copied to RAM, and the user will be served from RAM.
And while the information is copied from hard disk, it is placed in what you call the page cache.
So the page cache stores recently requested data to make it faster if the same data is needed again.
And if the user starts modifying data, it will go to RAM as well, and from RAM it will be copied to the hard disk, but that will only happen if the data has been sitting in RAM long enough.
Data won’t be written immediately from RAM to hard disk, but to optimize write to the hard disk, Linux works with the concept of dirty cache.
It tries to buffer as much as data in order to create an efficient write request.
So as you can see in this small diagram, everything that happens on your computer goes through RAM.
So using RAM on a Linux computer is essential for the well working of the Linux operating system.

Now we will discuss the individual part of Linux memory management and understand different terminologies related to this flow.

Understanding Virtual Memory

When analysing Linux memory usage, you should know how Linux uses Virtual and Resident Memory. Virtual Memory on Linux is to be taken literally: it is a non-existing amount of memory that the Linux kernel can be referred to.

Currently my RHEL 7 Linux has 128GB of Total Physical Memory

But as you see this node also has 32TB of Virtual Memory

Now the idea is that if in Linux, when a process is loading, this process needs memory pointers, and these memory pointers don’t really have to refer to actual physical RAM, and that is why we are using virtual memory.
Virtual Memory is used by the Linux kernel to allow programs to make a memory reservation.
After making this reservation, no other application can reserve the same memory.
Making the reservation is a matter of setting pointers and nothing else. It doesn’t mean that the memory reservation is also actually going to be used.
When a program has to use the memory it has reserved, it is going to issue a malloc system call, which means that the memory is actually going to be allocated. At that moment, we’re talking about resident memory.

What is memory over-allocation (over-commitment) and OOM?

In top command we can see the virt column and the res column.
The VIRT is for Virtual Memory. That’s the amount of kilobytes that currently the process has allocated.
And RES is for Resident, that is what it is really using.
I have sorted the output to show processes with most memory consumption.

We can see in the VIRT section that huge amount of memory is allocated to the process such as for java 22.4GB of virtual memory is allocated while only 4.8GB is used
If you add all of these VIRT memory to one another, you are getting far beyond the total of 128GB of physical RAM that is available in this system.
That is what we call memory over-allocation.
To tune the behavior of over committing memory, you can write to the /proc/sys/vm/overcommit_memory parameter. This parameter can have some values.
The default value is 0, which means that the kernel checks if it still has memory available before granting it. If that doesn’t give you the performance you need,
The value 1, means that the system thinks there is enough memory in all cases. This is good for performance of memory-intensive tasks but may result in processes getting killed automatically.
The value of 2, means that the kernel fails the memory request if there is not enough memory available.

Let us understand in laymen terms,

This means that when any application or process requests for memory, kernel will always honour that request and «give«.
Please NOTE, that kernel gives certain amount of memory but this memory is not marked as «used«.
Instead this is considered as «virtual memory» and only when the application or process tries to write some data into the memory, kernel will mark that section of memory as «used«.
So if suddenly one or some process would start using more resident memory (RES), the kernel needs to honour that request, and the result is that you can reach a situation where there is no more memory available.
That is called OOM (Out Of Memory) situation when your system is running low on memory, and it is getting out of memory
In such case the out of memory killer becomes active, and it will kill the process that least requires to have the memory, and that is kind of a random situation, so you’ll get a random process killed if your system is running out of memory.

Источник