Question

'man top'所说的是：RES = CODE + DATA

q: RES -- Resident size (kb)
The non-swapped physical memory a task has used.
RES = CODE + DATA.

r: CODE -- Code size (kb)
The amount of physical memory devoted to executable code, also known as the 'text        resident set' size or TRS.

s: DATA -- Data+Stack size (kb)
The amount of physical memory devoted to other than executable code, also known as the   'data >resident set' size or DRS.

当我运行'top -p 4258'时，我得到以下结果：

PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  CODE DATA COMMAND
258 root      16   0  3160 1796 1328 S  0.0  0.3   0:00.10  476  416 bash

1796！= 476 + 416

为什么？

PS： linux发布：

linux-iguu:~ # lsb_release -a
LSB Version:    core-2.0-noarch:core-3.0-noarch:core-2.0-ia32:core-3.0-ia32:desktop-3.1-ia32:desktop-3.1-noarch:graphics-2.0-ia32:graphics-2.0-noarch:graphics-3.1-ia32:graphics-3.1-noarch
Distributor ID: SUSE LINUX
Description:    SUSE Linux Enterprise Server 9 (i586)
Release:        9
Codename:       n/a

内核版本：

linux-iguu:~ # uname -a
Linux linux-iguu 2.6.16.60-0.21-default #1 Tue May 6 12:41:02 UTC 2008 i686 i686 i386 GNU/Linux

Answer 1

我将借助一个程序分配和使用内存时会发生什么的例子来解释这一点。具体来说，这个程序：

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>

int main(){

        int *data, size, count, i;

        printf( "fyi: your ints are %d bytes large\n", sizeof(int) );

        printf( "Enter number of ints to malloc: " );
        scanf( "%d", &size );
        data = malloc( sizeof(int) * size );
        if( !data ){
                perror( "failed to malloc" );
                exit( EXIT_FAILURE );
        }

        printf( "Enter number of ints to initialize: " );
        scanf( "%d", &count );
        for( i = 0; i < count; i++ ){
                data[i] = 1337;
        }

        printf( "I'm going to hang out here until you hit <enter>" );
        while( getchar() != '\n' );
        while( getchar() != '\n' );

        exit( EXIT_SUCCESS );
}

这是一个简单的程序，询问你要分配多少个整数，分配它们，询问有多少个整数要初始化，然后初始化它们。对于我分配1250000个整数并初始化500000个整数的运行：

$ ./a.out
fyi: your ints are 4 bytes large
Enter number of ints to malloc: 1250000
Enter number of ints to initialize: 500000

Top报告以下信息：

  PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  SWAP CODE DATA COMMAND
<program start>
11129 xxxxxxx   16   0  3628  408  336 S    0  0.0   0:00.00 3220    4  124 a.out
<allocate 1250000 ints>
11129 xxxxxxx   16   0  8512  476  392 S    0  0.0   0:00.00 8036    4 5008 a.out
<initialize 500000 ints>
11129 xxxxxxx   15   0  8512 2432  396 S    0  0.0   0:00.00 6080    4 5008 a.out

相关信息是：

                          DATA CODE  RES VIRT
before allocation:         124    4  408 3628
after 5MB allocation:     5008    4  476 8512
after 2MB initialization: 5008    4 2432 8512

在我对5MB数据进行malloc后，VIRT和DATA都增加了〜5MB，但RES却没有。在触及我分配的2MB整数后，RES确实增加了，但DATA和VIRT保持不变。

VIRT是进程使用的虚拟内存总量，包括共享内容和what is over-committed。 DATA是未共享且不是代码文本的虚拟内存量。即，它是进程的虚拟堆栈和堆。 RES不是虚拟的：它是对该进程在该特定时间实际使用的内存量的测量。

所以在你的情况下，大的不等式CODE + DATA＆lt; RES可能是该过程包含的共享库。在我的例子中（和你的），SHR + CODE + DATA更接近于RES。

希望这会有所帮助。顶部和ps有很多挥手和伏都教。有很多文章（咆哮？）在网上关于这些差异。例如，this和this。

Answer 2

这个解释对解决我的一些疑问非常有用。谢谢！同时，在我理解linux内存管理知识的过程中尝试添加一些内容。如果有任何误解，请纠正我！

现代OS流程概念基于虚拟内存。虚拟内存系统包括RAM + SWAP; 所以我认为大多数与进程相关的内存概念都是指虚拟内存，除了有一些补充说明。
分配给流程的任何虚拟地址（页面）都处于以下状态：

a）已分配，但没有映射到任何物理内存（类似于COW）

b）已分配，已映射到物理内存

c）已分配，已映射到交换内存。
top命令的字段输出：

a）VIRT - 它指的是进程拥有权限的所有虚拟内存访问，无论它已经映射到物理内存还是已交换记忆，甚至没有任何映射。

b）RES - 它指的是已经映射到物理地址但仍在RAM中的虚拟地址。

c）SWAP - 指已经映射到物理地址的虚拟地址，并将其交换到SWAP空间。

d）SHR - 它指的是进程可用的共享内存（VM？）
e）CODE + DATA - CODE可以处于2.b / 2.c状态，DATA可以处于3状态2.a / 2.b / 3.c和3.b中的任何一个状态/3.c也有一个名为＆＃34; USED＆＃34;。

4）所以计算可能如下：

a）VIRT（VM）= RES（内存中的VM）+ SWAP（交换中的VM）+未映射的VM（DATA，SHR？）。

b）USED = RES + SWAP

c）SWAP = CODE（内存中的vm）+ DATA（内存中的vm）+ SHR（内存中的vm？）

d）RES = CODE（内存中的vm）+ DATA（内存中的vm）+ SHR（内存中的vm？）

至少DATA段仍然有一个＆＃34; DATA（VM未映射）＆＃34;，这可以从malloc示例上面观察到。这与top命令的联机帮助页略有不同，后者表示＆＃34; DATA：专用于可执行代码以外的物理内存量，也称为数据驻留集大小或DRS＆＃34;。再次感谢。因此（CODE + DATA + SHR）的数量通常大于RES，因为至少DATA（vm未映射）实际上是在＆＃34; DATA＆＃34;中计算的，而不是像manpge声称的那样。

此致

RES！= CODE + DATA在top命令的输出信息中，为什么？

2 个答案: