精华内容
下载资源
问答
  • linux top命令 实存(RES)与虚存(VIRT)详解 今天被人问到 linux系统里top命令输出的VIRT这个虚拟内存是从哪分配的呢? 有点懵,所以找了找资料,翻了翻博客 一、基础概念 VIRT: 1、进程“需要的”虚拟内存大小,...

    linux top命令 实存(RES)与虚存(VIRT)详解

    今天被人问到 linux系统里top命令输出的VIRT这个虚拟内存是从哪分配的呢?
    有点懵,所以找了找资料,翻了翻博客

    一、基础概念

    VIRT:

    1、进程“需要的”虚拟内存大小,包括进程使用的库、代码、数据,以及malloc、new分配的堆空间和分配的栈空间等;
    2、假如进程新申请10MB的内存,但实际只使用了1MB,那么它会增长10MB,而不是实际的1MB使用量。
    3、VIRT = SWAP + RES
    

    RES:

    1、进程当前使用的内存大小,包括使用中的malloc、new分配的堆空间和分配的栈空间,但不包括swap out量;
    2、包含其他进程的共享;
    3、如果申请10MB的内存,实际使用1MB,它只增长1MB,与VIRT相反;
    4、关于库占用内存的情况,它只统计加载的库文件所占内存大小。
    5、RES = CODE + DATA
    

    SHR:

    1、除了自身进程的共享内存,也包括其他进程的共享内存;
    2、虽然进程只使用了几个共享库的函数,但它包含了整个共享库的大小;
    3、计算某个进程所占的物理内存大小公式:RES – SHR;
    4、swap out后,它将会降下来。
    

    二、测试

    (1) 使用堆分配内存, 进行测试:

     1	#include <iostream>
     2 #include <stdio.h>
     3 #include <string.h>
     4 
     5 int main()
     6 {
     7     int test = 0;
     8     //分配512M, 未使用
     9     char * p = new char [1024*1024*512];
    10     scanf("%d", &test); //等待输入
    11 
    12     //使用10M
    13     memset(p, 0, 1024 * 1024 * 10);
    14     scanf("%d", &test); //等待输入
    15 
    16     //使用50M
    17     memset(p, 0, 1024 * 1024 * 50);
    18     scanf("%d", &test); //等待输入
    19     delete [] p;
    20     return 0;
    21 }
    

    执行:

    new 512M后,VIRT/RES
    在这里插入图片描述
    使用10M后,VIRT/RES
    在这里插入图片描述
    使用50M后,VIRT/RES
    在这里插入图片描述
    (2) 使用栈分配内存进行测试:

     1 #include <iostream>
     2 #include <stdio.h>
     3 #include <string.h>
     4 
     5 int main()
     6 {
     7     int test = 0;
     8     //20M栈, 未使用
     9     char p[1024*1024*20];
    10     scanf("%d", &test);    //等待输入
    11 
    12     //使用10M
    13     memset(p, 0, 1024 * 1024 * 10);
    14     scanf("%d", &test);    //等待输入
    15     return 0;
    16 }
    

    执行:

    栈上申请20M
    在这里插入图片描述
    使用10M
    在这里插入图片描述

    1. 总结

    堆、栈分配的内存,如果没有使用是不会占用实存的,只会记录到虚存。
    如果程序占用实存比较多,说明程序申请内存多,实际使用的空间也多。
    如果程序占用虚存比较多,说明程序申请来很多空间,但是没有使用。

    参考:

    1. https://www.cnblogs.com/zmlctt/p/3987181.html

    2. https://blog.csdn.net/huyiyang2010/article/details/7815491

    3. https://www.cnblogs.com/xudong-bupt/p/8643094.html

    展开全文
  • Linux中的top, htop资源管理器命令中的VIRT列和RES列的区别 Linux运维都知道,VIRT是虚拟内存,RES是物理内存 但是如何在VIRT中申请内存,如何在RES中申请内存,你知道吗?你以为只是malloc,new这么简单吗? 奉上我作的...
  • Top命令监控某个进程的资源占有情况  下面是各种内存: VIRT:virtual memory usage   1、进程“需要的”虚拟内存大小,包括进程使用的库、代码、数据等   2、假如进程申请100m的内存,但实际只使用...

    Top命令监控某个进程的资源占有情况 

    下面是各种内存:

    VIRT:virtual memory usage 

        1、进程“需要的”虚拟内存大小,包括进程使用的库、代码、数据等 
        2、假如进程申请100m的内存,但实际只使用了10m,那么它会增长100m,而不是实际的使用量 

    RES:resident memory usage 常驻内存 

        1、进程当前使用的内存大小,但不包括swap out 
        2、包含其他进程的共享 
        3、如果申请100m的内存,实际使用10m,它只增长10m,与VIRT相反 
        4、关于库占用内存的情况,它只统计加载的库文件所占内存大小 

    SHR:shared memory 

        1、除了自身进程的共享内存,也包括其他进程的共享内存 
        2、虽然进程只使用了几个共享库的函数,但它包含了整个共享库的大小 
        3、计算某个进程所占的物理内存大小公式:RES – SHR 
        4、swap out后,它将会降下来 

    DATA 

        1、数据占用的内存。如果top没有显示,按f键可以显示出来。 
        2、真正的该程序要求的数据空间,是真正在运行中要使用的。

    展开全文
  • linux的top命令源码解析:RES指标

    千次阅读 2020-09-06 08:49:23
    C语言源码程序:Makefile格式的linux系统的top命令源码。 top所在的系统:ubuntu 14.04 一、源码导入 linux的top命令采用的是procps-ng项目,可以通过Clion 导入Makefile格式的C语言源程序:procps项目 这篇博客将...

    CLion:2019.3.6
    源码管理平台:Macbook Pro 10.12.6
    C语言源码程序:Makefile格式的linux系统的top命令源码。
    top所在的系统:ubuntu 14.04

    一、源码导入

    linux的top命令采用的是procps-ng项目,可以通过Clion 导入Makefile格式的C语言源程序:procps项目 这篇博客将源码进行下载和导入。

    二、RES 指标的源码分析

    1、输入top命令后显示如下:
    在这里插入图片描述
    对于RES指标, 代表PID进程占用的物理内存,其中包括共享库内存,RES的数据是怎么计算得来的呢,接下来我们将通过查看源码来了解这个数据的源头。

    2、top的源码分析
    top的源码位于top.c文件中:
    在这里插入图片描述
    top.c通过task_show如下进行获取res的数值,

    /*
     * Build the information for a single task row and
     * display the results or return them to the caller. */
    static const char *task_show (const WIN_t *q, const int idx) {
      ... 省略....
     #define pages2K(n)  (unsigned long)( (n) << Pg2K_shft )
       ... 省略....
       // we must begin a row with a possible window number in mind...
       *(rp = rbuf) = '\0';
       if (Rc.mode_altscr) rp = scat(rp, " ");
       ... 省略....
       for (x = 0; x < q->maxpflgs; x++) {
          const char *cp = NULL;
          FLG_t       i = q->procflgs[x];
          ... 省略....
          switch (i) {
           ... 省略....
             case EU_MEM:
                cp = scale_pcnt((float)pages2K(p->resident) * 100 / kb_main_total, W, Jn);
             ... 省略....
             case EU_NMA:
                cp = make_num(numa_node_of_cpu(p->processor), W, Jn, AUTOX_NO, 0);
                break;
             case EU_RES:
                cp = scale_mem(S, pages2K(p->resident), W, Jn);
                break;
             case EU_SHR:
                cp = scale_mem(S, pages2K(p->share), W, Jn);
                break;
             case EU_SWP:
                cp = scale_mem(S, p->vm_swap, W, Jn);
                break;
             ... 省略....
             default:                 // keep gcc happy
                continue;
          } // end: switch 'procflag'
     #undef pages2K
    } // end: task_show
    

    其中RES获取的片段如下:
    在这里插入图片描述
    其中p->resident 是res的数据源,p的结构:

       proc_t *p = q->ppt[idx];
    

    其中proc_t的结构体主要内容如下所示:

    // Basic data structure which holds all information we can get about a process.
    // (unless otherwise specified, fields are read from /proc/#/stat)
    //
    // Most of it comes from task_struct in linux/sched.h
    //
    typedef struct proc_t {
    // 1st 16 bytes
        int
            tid,		// (special)       task id, the POSIX thread ID (see also: tgid)
        	ppid;		// stat,status     pid of parent process
        unsigned long       // next 2 fields are NOT filled in by readproc
        ..........省略.........
        long
    	priority,	// stat            kernel scheduling priority
    	nice,		// stat            standard unix nice level of process
    	rss,		// stat            identical to 'resident'
    	alarm,		// stat            ?
        // the next 7 members come from /proc/#/statm
    	size,		// statm           total virtual memory (as # pages)
    	resident,	// statm           resident non-swapped memory (as # pages)
    	share,		// statm           shared (mmap'd) memory (as # pages)
    	trs,		// statm           text (exe) resident set (as # pages)
    	lrs,		// statm           library resident set (always 0 w/ 2.6)
    	drs,		// statm           data+stack resident set (as # pages)
    	dt;		// statm           dirty pages (always 0 w/ 2.6)
        unsigned long
    	vm_size,        // status          equals 'size' (as kb)
    	vm_lock,        // status          locked pages (as kb)
    	vm_rss,         // status          equals 'rss' and/or 'resident' (as kb)
    	vm_rss_anon,    // status          the 'anonymous' portion of vm_rss (as kb)
    	vm_rss_file,    // status          the 'file-backed' portion of vm_rss (as kb)
    	vm_rss_shared,  // status          the 'shared' portion of vm_rss (as kb)
    	vm_data,        // status          data only size (as kb)
    	vm_stack,       // status          stack only size (as kb)
    	vm_swap,        // status          based on linux-2.6.34 "swap ents" (as kb)
        ..........省略.........
        const char
            *lxcname;       // n/a             lxc container name
    } proc_t;
    

    所以top的res是从proc_t->resident获取的,其中resident的单位是页面,是通过pages2K将页面数量转换成字节数, 页面的大小是4K:

             case EU_RES:
                cp = scale_mem(S, pages2K(p->resident), W, Jn);
    

    其中pages2K函数:

       /* The run-time acquired page stuff */
       static unsigned Pg2K_shft = 0;
       // get virtual page stuff
       i = page_bytes; // from sysinfo.c, at lib init
       while(i > 1024) { i >>= 1; Pg2K_shft++; }
    
     #define pages2K(n)  (unsigned long)( (n) << Pg2K_shft )
    

    如上所示:q->ppt[idx]又是从哪儿初始化的呢?
    如下代码所示:q作为task_show函数传递进来:

    static const char *task_show (const WIN_t *q, const int idx) {
    

    WIN_t的结构定义如下:

    
            /* This structure stores configurable information for each window.
               By expending a little effort in its creation and user requested
               maintenance, the only real additional per frame cost of having
               windows is an extra sort -- but that's just on pointers! */
    typedef struct WIN_t {
       FLG_t  pflgsall [PFLAGSSIZ],        // all 'active/on' fieldscur, as enum
              procflgs [PFLAGSSIZ];        // fieldscur subset, as enum
       RCW_t  rc;                          // stuff that gets saved in the rcfile
       int    winnum,          // a window's number (array pos + 1)
              winlines,        // current task window's rows (volatile)
              maxpflgs,        // number of displayed procflgs ("on" in fieldscur)
              totpflgs,        // total of displayable procflgs in pflgsall array
              begpflg,         // scrolled beginning pos into pflgsall array
              endpflg,         // scrolled ending pos into pflgsall array
              begtask,         // scrolled beginning pos into Frame_maxtask
              begnext,         // new scrolled delta for next frame's begtask
    #ifndef SCROLLVAR_NO
              varcolbeg,       // scrolled position within variable width col
    #endif
              varcolsz,        // max length of variable width column(s)
              usrseluid,       // validated uid for 'u/U' user selection
              usrseltyp,       // the basis for matching above uid
              usrselflg,       // flag denoting include/exclude matches
              hdrcaplen;       // column header xtra caps len, if any
       char   capclr_sum [CLRBUFSIZ],      // terminfo strings built from
              capclr_msg [CLRBUFSIZ],      //   RCW_t colors (& rebuilt too),
              capclr_pmt [CLRBUFSIZ],      //   but NO recurring costs !
              capclr_hdr [CLRBUFSIZ],      //   note: sum, msg and pmt strs
              capclr_rowhigh [CLRBUFSIZ],  //         are only used when this
              capclr_rownorm [CLRBUFSIZ],  //         window is the 'Curwin'!
              cap_bold [CAPBUFSIZ],        // support for View_NOBOLD toggle
              grpname [GRPNAMSIZ],         // window number:name, printable
    #ifdef USE_X_COLHDR
              columnhdr [ROWMINSIZ],       // column headings for procflgs
    #else
              columnhdr [SCREENMAX],       // column headings for procflgs
    #endif
             *captab [CAPTABMAX];          // captab needed by show_special()
       struct osel_s *osel_1st;            // other selection criteria anchor
       int    osel_tot;                    // total of other selection criteria
       char  *findstr;                     // window's current/active search string
       int    findlen;                     // above's strlen, without call overhead
       proc_t **ppt;                       // this window's proc_t ptr array
       struct WIN_t *next,                 // next window in window stack
                    *prev;                 // prior window in window stack
    } WIN_t;
    

    关键的代码在readproc.c,如下代码所示:

    //
    // This reads process info from /proc in the traditional way, for one process.
    // The pid (tgid? tid?) is already in p, and a path to it in path, with some
    // room to spare.
    static proc_t* simple_readproc(PROCTAB *restrict const PT, proc_t *restrict const p) {
         ......省略.......
        if (flags & PROC_FILLMEM) {                 // read /proc/#/statm
            if (likely(file2str(path, "statm", &ub) != -1))
                statm2proc(ub.buf, p);
        }
         ......省略.......
    

    其中statm2proc的函数实现如下:

    static void statm2proc(const char* s, proc_t *restrict P) {
        sscanf(s, "%ld %ld %ld %ld %ld %ld %ld",
    	   &P->size, &P->resident, &P->share,
    	   &P->trs, &P->lrs, &P->drs, &P->dt);
    }
    

    可以看出,top的RES是从/proc/pid/statm文件中格式化读出来的。

    展开全文
  • top命令之RES,DATA

    千次阅读 2018-07-28 15:41:22
    随时监控进程的内存使用大小对于服务的稳定和平时问题的查找就有很... linux提供top命令,这个可以实时查看每个进程的内存使用量,其中主要有两个参数需要注意,RES和DATA参数。 top -p pid 然后 使用 f再点击DAT...

      随时监控进程的内存使用大小对于服务的稳定和平时问题的查找就有很重要的意义,比如nginx+php-fpm技术栈中对于每个php-fpm的进程内存的大小会影响进程的开启数等。

      那么如何查看运行中的进程占用的内存大小呢? linux提供top命令,这个可以实时查看每个进程的内存使用量,其中主要有两个参数需要注意,RES和DATA参数。

           top -p pid 然后 使用 f再点击DATA对应的标识就可以看见 DATA这一列了    

           

         RES是进程实际使用的,VIRT是虚拟和物理的总和,比如php-fpm的进程有内存限制 这个只能限制住RES。

      CODE是编译器获取的,VIRT和DATA是 通过 malloc和free mmap等获取的,RES是操作系统分配的。


      可以使用下面的实际例子来讲解下:

    #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复制代码

        在malloc了1250000后,VIRT和DATA增加了,但是RES没变。在初始化后 VIRT和DATA没变,但是RES增加了。

        VIRT是进程所有的虚拟内存,包括共享的,入动态链接库等,DATA是虚拟栈和堆的大小。RES不是虚拟的,它是内存在指定时间真实使用的内存。


    展开全文
  • top命令VIRT,RES,SHR,DATA

    千次阅读 2018-04-25 15:02:19
    linux top命令VIRT,RES,SHR,DATA的含义VIRT:virtual memory usage 虚拟内存1、进程“需要的”虚拟内存大小,包括进程使用的库、代码、数据等2、假如进程申请100m的内存,但实际只使用了10m,那么它会增长100m,而...
  • Java应用Top命令RES内存占用高分析

    千次阅读 2020-08-31 15:41:43
    参考:Java应用Top命令RES内存占用高分析
  • [转]剖析top命令显示的VIRT RES SHR值

    千次阅读 2018-08-09 16:17:34
    [转]剖析top命令显示的VIRT RES SHR值 http://yalung929.blog.163.com/blog/static/203898225201212981731971/   http://www.fuzhijie.me/?p=741     引 言 :  top 命令 作为Linux下最常用的性能分析工具...
  • linux top命令VIRT,RES,SHR,DATA的含义

    千次阅读 2019-07-09 16:58:30
    VIRT:virtual memory usage 虚拟内存 1、进程“需要的”虚拟内存...RES:resident memory usage 常驻内存 1、进程当前使用的内存大小,但不包括swap out 2、包含其他进程的共享 3、如果申请100m的内存,实际使用...
  • 1 VIRT RES SHR的准确含义     三个内存指标,VRIT,RES,SHR准确含义是什么?谁能告诉我们?...首先这三个数据的源头,肯定是内核,进程的相关数据结构肯定是由内核维护。那么top作为一个用户空间的...
  • top命令介绍、实存(RES) 与 虚存(VIRT)区别、线程未释放导致内存泄漏 top查看VIRT持续增长 内存泄漏定位
  • 2020.10.20 PaddlePaddle版本Res2Net达到85.13%top-1 acc。 在ImageNet上: 。 2020.8.21发布了使用Res2Net进行检测和分割的在线演示: ://mc.nankai.edu.cn/res2net-det 2020.7.29在ImageNet上发布Res2Net的培训...
  • linux top VIRT RES SHR SWAP DATA内存参数详解

    万次阅读 热门讨论 2013-08-09 18:26:25
    Linux top VIRT RES SHR SWAP DATA内存参数详解 其实很早之前就想开博客,写一写码农几年自己积攒下来的知识与见解。看过很多文章有过很多感触,有些收获很值得梳理一下认真思考反思的。今天就先从基本的top开始吧,...
  • VIRT 表示进程的虚拟(地址)空间大小,其包含进程实际使用的大小...RES 表示进程的常驻内存大小,准确表示当前有多少物理内存被这个进程消费,这个和MEM是对应的, 这个大小永远要比VIRT小,因为程序大部分使用到c库 ...
  •  在linux环境下使用top命令查看java命令的mem比值一直在缓慢的增加,第二天出现了服务宕机的情况,生成hs_err的log   测试环境的配置:阿里云ecs,总物理内存7.6g 。 java服务启动参数xmx为total的7...
  • top指令输出的VIRT, RES 和SHR有什么区别 VIRT 意味着进程虚拟空间的大小, 是真实使用的内存,加上映射进程自己使用的内存(如, X server使用显卡内存), 加上映射磁盘文件使用的内存(主要是加载共享程序库文件), 加上...
  • 在统计效果时, QA问是统计RES(实存)还是VIRT(虚存)。 在网上学习看了一些博客,这里自己总结一下RES和VIRT的区别。 1. 概念 VIRT: 1、进程“需要的”虚拟内存大小,包括进程使用的库、代码、数据,以及malloc...
  • 今天在观察服务器运行情况的时候用top命令看我的程序是否在运行,一般只关心内存,CPU这些参数,但是它还有很多的参数,我们一起来看看其他的参数都是什么意思。 VIRT:Virtual memory usage 虚拟内存 1、进程...
  • ![图片说明](https://img-ask.csdn.net/upload/201504/30/1430373062_720597.png) man top后能够看到VIRT = SWAP + RES 但是我看swap本身used为0,这里使用的SWAP指的什么呢
  • Linux 的 top命令详解 这张图是真实的阿里云云服务器上,使用了top命令之后的信息。 1.上半部分显示了整体系统负载情况 1.1 top 第一行: 从左到右依次为当前系统时间,系统运行的时间,系统在之前1min、5min和15...
  • http://www.fuzhijie.me/?p=741 ...  引 言: top命令作为Linux下最常用的性能分析工具之一,可以监控、收集进程的CPU、IO、内存使用情况。比如我们可以通过top命令获得一个进程使用了多少虚拟内存(VIRT)、物理内
  • linux top:virt res 内存变化

    千次阅读 2012-04-28 13:11:55
    在程序中使用malloc(大块)的内存,如果没有使用不会反应在res里面,只反应在virt中,可以测试一下:   #include #include #include #include #include #include using namespace std; void* foo...
  • Linux中ps与top命令 这两个命令都是查看系统进程信息的命令,但是用处有点儿不同 一:.ps命令–提供系统过去信息的一次性快照 也就是说ps命令能够查看刚刚系统的进程信息 命令:ps aux或者ps lax [root@Linux ~]# ...
  • linux ps top 命令 VSZ,RSS,TTY,STAT, VIRT,RES,SHR,DATA的含义

    万次阅读 多人点赞 2014-08-29 10:00:54
    VIRT:virtual memory usage 虚拟内存 1、进程“需要的”虚拟内存大小,包括进程使用的库、代码、数据等 ...RES:resident memory usage 常驻内存 1、进程当前使用的内存大小,但不包括swap out
  • linux top命令VIRT,RES,SHR,DATA含义

    千次阅读 2018-07-03 10:23:10
    linux top命令VIRT,RES,SHR,DATA的含义 VIRT:virtual memory usage 虚拟内存 1、进程“需要的”虚拟内存大小,包括进程使用的库、代码、数据等 2、假如进程申请100m的内存,但实际只使用了10m,那么它会增长100m...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 187,968
精华内容 75,187
关键字:

restop