精华内容
下载资源
问答
  • 转载一篇关于进程内存计算和CGROUP内存计算差异的文章 http://hustcat.github.io/memory-usage-in-process-and-cgroup/ 在Linux内核,对于进程的内存使用与Cgroup的内存使用统计有一些相同和不同的地方。 进程的...

    转载一篇关于进程内存计算和CGROUP内存计算差异的文章
    http://hustcat.github.io/memory-usage-in-process-and-cgroup/

    在Linux内核,对于进程的内存使用与Cgroup的内存使用统计有一些相同和不同的地方。
    进程的内存统计
    一般来说,业务进程使用的内存主要有以下几种情况:
    (1)用户空间的匿名映射页(Anonymous pages in User Mode address spaces),比如调用malloc分配的内存,以及使用MAP_ANONYMOUS的mmap;当系统内存不够时,内核可以将这部分内存交换出去;
    (2)用户空间的文件映射页(Mapped pages in User Mode address spaces),包含map file和map tmpfs;前者比如指定文件的mmap,后者比如IPC共享内存;当系统内存不够时,内核可以回收这些页,但回收之前可能需要与文件同步数据;
    (3)文件缓存(page in page cache of disk file);发生在程序通过普通的read/write读写文件时,当系统内存不够时,内核可以回收这些页,但回收之前可能需要与文件同步数据;
    (4)buffer pages,属于page cache;比如读取块设备文件。

    其中(1)和(2)是算作进程的RSS,(3)和(4)属于page cache。

    进程的内存统计

    与进程内存统计相关的几个文件:

    /proc/[pid]/stat
    (23) vsize  %lu
            Virtual memory size in bytes.
    (24) rss  %ld
            Resident Set Size: number of pages the process has
            in real memory.  This is just the pages which count
            toward text, data, or stack space.  This does not
            include pages which have not been demand-loaded in,
            or which are swapped out.

    RSS的计算:
    对应top的RSS列,do_task_stat源码

    #define get_mm_rss(mm)                    \
        (get_mm_counter(mm, file_rss) + get_mm_counter(mm, anon_rss))

    即RSS=file_rss + anon_rss
    statm的介绍

    /proc/[pid]/statm
    Provides information about memory usage, measured in pages.
    The columns are:
    
      size       (1) total program size
                 (same as VmSize in /proc/[pid]/status)
      resident   (2) resident set size
                 (same as VmRSS in /proc/[pid]/status)
      share      (3) shared pages (i.e., backed by a file)
      text       (4) text (code)
      lib        (5) library (unused in Linux 2.6)
      data       (6) data + stack
      dt         (7) dirty pages (unused in Linux 2.6)

    statm统计信息相关源码见函数proc_pid_statm

    int task_statm(struct mm_struct *mm, int *shared, int *text,
               int *data, int *resident)
    {
        *shared = get_mm_counter(mm, file_rss);
        *text = (PAGE_ALIGN(mm->end_code) - (mm->start_code & PAGE_MASK))
                                    >> PAGE_SHIFT;
        *data = mm->total_vm - mm->shared_vm;
        *resident = *shared + get_mm_counter(mm, anon_rss);
        return mm->total_vm;
    }

    top的SHR=file_rss。
    实际上,进程使用的共享内存,也是算到file_rss的,因为共享内存基于tmpfs。
    anon_rss与file_rss的计算源码

    static int __do_fault(struct mm_struct *mm, struct vm_area_struct *vma,
            unsigned long address, pmd_t *pmd,
            pgoff_t pgoff, unsigned int flags, pte_t orig_pte)
    {
        if (flags & FAULT_FLAG_WRITE) {
            if (!(vma->vm_flags & VM_SHARED)) {
                anon = 1;///anon page
    ...
            if (anon) {
                inc_mm_counter(mm, anon_rss);
                page_add_new_anon_rmap(page, vma, address);
            } else {
                inc_mm_counter(mm, file_rss);
                page_add_file_rmap(page);

    cgroup 的内存统计

    stat file
    memory.stat file includes following statistics
    
    # per-memory cgroup local status
    
    cache        - # of bytes of page cache memory.
    rss        - # of bytes of anonymous and swap cache memory (includes
            transparent hugepages).
    rss_huge    - # of bytes of anonymous transparent hugepages.
    mapped_file    - # of bytes of mapped file (includes tmpfs/shmem)
    pgpgin        - # of charging events to the memory cgroup. The charging
            event happens each time a page is accounted as either mapped
            anon page(RSS) or cache page(Page Cache) to the cgroup.
    pgpgout        - # of uncharging events to the memory cgroup. The uncharging
            event happens each time a page is unaccounted from the cgroup.
    swap        - # of bytes of swap usage
    dirty        - # of bytes that are waiting to get written back to the disk.
    writeback    - # of bytes of file/anon cache that are queued for syncing to
            disk.
    inactive_anon    - # of bytes of anonymous and swap cache memory on inactive
            LRU list.
    active_anon    - # of bytes of anonymous and swap cache memory on active
            LRU list.
    inactive_file    - # of bytes of file-backed memory on inactive LRU list.
    active_file    - # of bytes of file-backed memory on active LRU list.
    unevictable    - # of bytes of memory that cannot be reclaimed (mlocked etc).

    相关代码

    static void
    mem_cgroup_get_local_stat(struct mem_cgroup *mem, struct mcs_total_stat *s)
    {
        s64 val;
    
        /* per cpu stat */
        val = mem_cgroup_read_stat(&mem->stat, MEM_CGROUP_STAT_CACHE);
        s->stat[MCS_CACHE] += val * PAGE_SIZE;
        val = mem_cgroup_read_stat(&mem->stat, MEM_CGROUP_STAT_RSS);
        s->stat[MCS_RSS] += val * PAGE_SIZE;
        val = mem_cgroup_read_stat(&mem->stat, MEM_CGROUP_STAT_FILE_MAPPED);
        s->stat[MCS_FILE_MAPPED] += val * PAGE_SIZE;
        val = mem_cgroup_read_stat(&mem->stat, MEM_CGROUP_STAT_PGPGIN_COUNT);
        s->stat[MCS_PGPGIN] += val;
        val = mem_cgroup_read_stat(&mem->stat, MEM_CGROUP_STAT_PGPGOUT_COUNT);
        s->stat[MCS_PGPGOUT] += val;
        if (do_swap_account) {
            val = mem_cgroup_read_stat(&mem->stat, MEM_CGROUP_STAT_SWAPOUT);
            s->stat[MCS_SWAP] += val * PAGE_SIZE;
        }
    
        /* per zone stat */
        val = mem_cgroup_get_local_zonestat(mem, LRU_INACTIVE_ANON);
        s->stat[MCS_INACTIVE_ANON] += val * PAGE_SIZE;
        val = mem_cgroup_get_local_zonestat(mem, LRU_ACTIVE_ANON);
        s->stat[MCS_ACTIVE_ANON] += val * PAGE_SIZE;
        val = mem_cgroup_get_local_zonestat(mem, LRU_INACTIVE_FILE);
        s->stat[MCS_INACTIVE_FILE] += val * PAGE_SIZE;
        val = mem_cgroup_get_local_zonestat(mem, LRU_ACTIVE_FILE);
        s->stat[MCS_ACTIVE_FILE] += val * PAGE_SIZE;
        val = mem_cgroup_get_local_zonestat(mem, LRU_UNEVICTABLE);
        s->stat[MCS_UNEVICTABLE] += val * PAGE_SIZE;
    }



    数据结构

    struct mem_cgroup {
    ...
        /*
         * statistics. This must be placed at the end of memcg.
         */
        struct mem_cgroup_stat stat;   //  统计数据
    };
    
    /* memory cgroup 统计值  
     * Statistics for memory cgroup.
     */
    enum mem_cgroup_stat_index {
        /*
         * For MEM_CONTAINER_TYPE_ALL, usage = pagecache + rss.
         */
        MEM_CGROUP_STAT_CACHE,        /* # of pages charged as cache */
        MEM_CGROUP_STAT_RSS,       /* # of pages charged as anon rss */
        MEM_CGROUP_STAT_FILE_MAPPED,  /* # of pages charged as file rss */
        MEM_CGROUP_STAT_PGPGIN_COUNT,    /* # of pages paged in */
        MEM_CGROUP_STAT_PGPGOUT_COUNT,    /* # of pages paged out */
        MEM_CGROUP_STAT_EVENTS,    /* sum of pagein + pageout for internal use */
        MEM_CGROUP_STAT_SWAPOUT, /* # of pages, swapped out */
    
        MEM_CGROUP_STAT_NSTATS,
    };
    
    struct mem_cgroup_stat_cpu {
        s64 count[MEM_CGROUP_STAT_NSTATS];
    } ____cacheline_aligned_in_smp;
    
    struct mem_cgroup_stat {
        struct mem_cgroup_stat_cpu cpustat[0];
    };



    rss and cache

    cache    - # of bytes of page cache memory. rss    - # of bytes of anonymous and swap cache memory (includes transparent hugepages).
    
    
    static void mem_cgroup_charge_statistics(struct mem_cgroup *mem,
                         struct page_cgroup *pc,
                         long size)
    {
    ...
        cpustat = &stat->cpustat[cpu];
        if (PageCgroupCache(pc))
            __mem_cgroup_stat_add_safe(cpustat,
                MEM_CGROUP_STAT_CACHE, numpages);
        else
            __mem_cgroup_stat_add_safe(cpustat, MEM_CGROUP_STAT_RSS,
                numpages);
    
    static void __mem_cgroup_commit_charge(struct mem_cgroup *mem,
                           struct page_cgroup *pc,
                           enum charge_type ctype,
                           int page_size)
    {
    
        switch (ctype) {
        case MEM_CGROUP_CHARGE_TYPE_CACHE:
        case MEM_CGROUP_CHARGE_TYPE_SHMEM: //file cache + shm
            SetPageCgroupCache(pc);
            SetPageCgroupUsed(pc);
            break;
        case MEM_CGROUP_CHARGE_TYPE_MAPPED:
            ClearPageCgroupCache(pc);
            SetPageCgroupUsed(pc);
            break;
        default:
            break;
        }
        //  更新统计值
        mem_cgroup_charge_statistics(mem, pc, page_size);
    
    
    int mem_cgroup_cache_charge(struct page *page, struct mm_struct *mm,
                    gfp_t gfp_mask)
    {
    ...
        if (page_is_file_cache(page))
            return mem_cgroup_charge_common(page, mm, gfp_mask,
                    MEM_CGROUP_CHARGE_TYPE_CACHE, NULL); ///file cache
    
        /* shmem */
        if (PageSwapCache(page)) {
            ret = mem_cgroup_try_charge_swapin(mm, page, gfp_mask, &mem);
            if (!ret)
                __mem_cgroup_commit_charge_swapin(page, mem,
                        MEM_CGROUP_CHARGE_TYPE_SHMEM);
        } else
            ret = mem_cgroup_charge_common(page, mm, gfp_mask, ///shm memory
                        MEM_CGROUP_CHARGE_TYPE_SHMEM, mem);

    可以看到,cache包含共享内存和file cache


    mapped_file
    mapped_file - # of bytes of mapped file (includes tmpfs/shmem)

    void mem_cgroup_update_file_mapped(struct page *page, int val)
    {
    ...    __mem_cgroup_stat_add_safe(cpustat, MEM_CGROUP_STAT_FILE_MAPPED, val);
    __do_fault –> page_add_file_rmap –> mem_cgroup_update_file_mapped。
    inactive_anon
    inactive_anon    - # of bytes of anonymous and swap cache memory on inactive LRU list.
    static int shmem_getpage_gfp(struct inode *inode, pgoff_t index,
        struct page **pagep, enum sgp_type sgp, gfp_t gfp, int *fault_type)
    {
    ...
            lru_cache_add_anon(page);
    
    /**
     * lru_cache_add: add a page to the page lists
     * @page: the page to add
     */
    static inline void lru_cache_add_anon(struct page *page)
    {
        __lru_cache_add(page, LRU_INACTIVE_ANON);
    }

    从这里可以看到,共享内存会增加到INACTIVE_ANON。


    inactive_file
    inactive_file - # of bytes of file-backed memory on inactive LRU list.文件使用的page cache(不包含共享内存)

    static inline void lru_cache_add_file(struct page *page)
    {
        __lru_cache_add(page, LRU_INACTIVE_FILE);
    }
    add_to_page_cache_lru –> lru_cache_add_file.

    示例程序

    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <errno.h>
    #include <unistd.h>
    #include <sys/stat.h>
    #include <sys/types.h>
    #include <sys/ipc.h>
    #include <sys/shm.h>
    #define BUF_SIZE 4000000000   
    #define MYKEY 26 
    
    int main(int argc,char **argv){
        int shmid;
        char *shmptr;
    
        if((shmid = shmget(MYKEY,BUF_SIZE,IPC_CREAT)) ==-1){
            fprintf(stderr,"Create Share Memory Error0m~Z%s\n\a",strerror(errno));
            exit(1);
        }
    
        if((shmptr =shmat(shmid,0,0))==(void *)-1){
            printf("shmat error!\n");
            exit(1);
        }
    
        memset(shmptr,'\0',1000000000);
    
        printf("sleep...\n");
        while(1)
            sleep(1);
    
        exit(0);
    }

    执行程序前后,cgroup memory.stat的值:
    执行前:*

    # cat memory.stat 
    cache 1121185792
    rss 23678976
    rss_huge 0
    mapped_file 14118912
    inactive_anon 1002643456
    active_anon 23687168
    inactive_file 46252032
    active_file 72282112

    执行后:*

    # cat memory.stat 
    cache 2121187328
    rss 23760896
    rss_huge 0
    mapped_file 1014124544
    inactive_anon 2002608128
    active_anon 23736320
    inactive_file 46247936
    active_file 72286208
    
    #ipcs -m
    0x0000001a 229380     root       0          4000000000 1

    可以看到cgroup中,共享内存计算在cache、mapped_file、inactive_anon中。

    小结

    (1)进程rss与cgroup rss的区别
    进程的RSS为进程使用的所有物理内存(file_rss+anon_rss),即Anonymous pages+Mapped apges(包含共享内存)。
    cgroup RSS为(anonymous and swap cache memory),不包含共享内存。
    两者都不包含file cache。
    (2)cgroup cache包含file cache和共享内存。

    参考

    http://man7.org/linux/man-pages/man5/proc.5.html
    https://www.kernel.org/doc/Documentation/cgroups/memory.txt

    展开全文
  • linux进程内存占用情况统计

    千次阅读 2017-03-24 18:22:48
    很多人通过累加 “ps aux” 命令显示的 RSS 列来统计全部进程总共占用的物理内存大小,这是不对的。RSS(resident set size)表示常驻内存的大小,但是由于不同的进程之间会共享内存,所以把所有进程RSS进行累加的方法...

    free查看整体情况

    [root@server01 work]# free -k
             total       used       free     shared    buffers     cached
    Mem:      12201292   12055948     145344          0     246852    6433528
    -/+ buffers/cache:    5375568    6825724
    Swap:     12582904     886884   11696020
    

    top查看进行情况

    [root@server01 work]# top
    top - 17:54:51 up 435 days,  6:29,  1 user,  load average: 0.22, 0.36, 0.32
    Tasks: 192 total,   1 running, 191 sleeping,   0 stopped,   0 zombie
    Cpu(s):  2.9%us,  3.0%sy,  2.0%ni, 88.2%id,  0.0%wa,  0.0%hi,  0.7%si,  3.2%st
    Mem:  12201292k total, 12034188k used,   167104k free,   250704k buffers
    Swap: 12582904k total,   886908k used, 11695996k free,  6404224k cached
    
      PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND                                                                                                                        
    12988 work      20   0 6863m 1.5g 7812 S  1.0 13.0   3534:08 java                                                                                                                            
    15854 work      20   0 4588m 666m  11m S  1.0  5.6  44:57.38 java                                                                                                                            
    27347 work      20   0 4604m 664m  11m S  6.0  5.6  59:33.96 java                                                                                                                            
     8441 work      20   0 4588m 638m 7680 S  1.3  5.4 160:13.87 java                                                                                                                            
    31517 work      20   0 6567m 541m 7616 S  0.3  4.5  16:39.00 java                                                                                                                            
    12619 work      20   0 7260m 347m 4756 S  5.6  2.9   4440:26 mysqld
    

    PR:进程的优先级别,越小越优先被执行
    VIRT:进程占用的虚拟内存
    RES:进程占用的物理内存
    SHR:进程使用的共享内存
    S:进程的状态。S表示休眠,R表示正在运行,Z表示僵死状态,N表示该进程优先值为负数
    %CPU:进程占用CPU的使用率
    %MEM:进程使用的物理内存和总内存的百分比
    TIME+:该进程启动后占用的总的CPU时间,即占用CPU使用时间的累加值。
    COMMAND:进程启动命令名称

    ps命令

    ps -e -o 'pid,comm,args,pcpu,rsz,vsz,stime,user,uid'  
    其中rsz是是实际内存
    
    ps -e -o 'pid,comm,args,pcpu,rsz,vsz,stime,user,uid' | grep java |  sort -nrk5
    其中rsz为实际内存,按内存排序,由大到小
    

    统计当前所有进程占用的内存

    使用ps命令统计

    通常,很多用户会使用如下ps命令进行统计

    ps aux | awk '{mem += $6} END {print mem/1024/1024}'
    

    但是,这里存在一个问题是,free没有专门统计另一项缓存: Slab。所以上述ps命令统计的结果与free展示的结果存在较大出入。

    Slab Allocation是Linux 2.2之后引入的一个内存管理机制,专门用于缓存内核的数据对象,可以理解为一个内核专用的对象池,可以提高系统性能并减少内存碎片。(Linux 2.6.23之后,SLUB成为了默认的allocator)。可查看meminfo文件了解slab信息。

    cat /proc/meminfo | grep Slab
    

    统计/proc/进程id/smaps

    很多人通过累加 “ps aux” 命令显示的 RSS 列来统计全部进程总共占用的物理内存大小,这是不对的。RSS(resident set size)表示常驻内存的大小,但是由于不同的进程之间会共享内存,所以把所有进程RSS进行累加的方法会重复计算共享内存,得到的结果是偏大的。

    正确的方法是累加 /proc/[1-9]*/smaps 中的 Pss 。/proc//smaps 包含了进程的每一个内存映射的统计值,详见proc(5)的手册页。Pss(Proportional Set Size)把共享内存的Rss进行了平均分摊,比如某一块100MB的内存被10个进程共享,那么每个进程就摊到10MB。这样,累加Pss就不会导致共享内存被重复计算了。

    命令如下:

    grep Pss /proc/[1-9]*/smaps | awk ‘{total+=$2}; END {print total}’
    

    需要注意的是,全部进程占用的内存并不等于 free 命令所显示的 “used memory”,因为“used memory”不仅包含了进程所占用的内存,还包含cache/buffer以及kernel动态分配的内存等等。

    调整系统内存管理

    /etc/sysctl.conf里有几个对内存管理影响比较大的配置,以下配置项的文档见vm.txt。

    vm.vfs_cache_pressure

    系统在进行内存回收时,会先回收page cache, inode cache, dentry cache和swap cache。vfs_cache_pressure越大,每次回收时,inode cache和dentry cache所占比例越大。

    vfs_cache_pressure默认是100,值越大inode cache和dentry cache的回收速度会越快,越小则回收越慢,为0的时候完全不回收(OOM)。

    linux kernel VFS layer

    参考资料

    内存问题排查

    展开全文
  • 很多人通过累加 “ps aux” 命令显示的 RSS 列来统计全部进程总共占用的物理内存大小,这是不对的。RSS(resident set size)表示常驻内存的大小,但是由于不同的进程之间会共享内存,所以把所有进程RSS进行累加的方法...

    原文地址:http://linuxperf.com/?p=143


    很多人通过累加 “ps  aux” 命令显示的 RSS 列来统计全部进程总共占用的物理内存大小,这是不对的。RSS(resident set size)表示常驻内存的大小,但是由于不同的进程之间会共享内存,所以把所有进程RSS进行累加的方法会重复计算共享内存,得到的结果是偏大的。


    正确的方法是累加 /proc/[1-9]*/smaps 中的 Pss 。/proc/<pid>/smaps 包含了进程的每一个内存映射的统计值,详见proc(5)的手册页。Pss(Proportional Set Size)把共享内存的Rss进行了平均分摊,比如某一块100MB的内存被10个进程共享,那么每个进程就摊到10MB。这样,累加Pss就不会导致共享内存被重复计算了。


    命令如下:
    $ grep Pss /proc/[1-9]*/smaps | awk ‘{total+=$2}; END {print total}’


    需要注意的是,全部进程占用的内存并不等于 free 命令所显示的 “used memory”,因为“used memory”不仅包含了进程所占用的内存,还包含cache/buffer以及kernel动态分配的内存等等。






    # grep Pss /proc/[1-9]*/smaps | awk '{total+=$2}; END {print total}'
    2296454
     
    # free -k
                  total        used        free      shared  buff/cache   available
    Mem:        3809036     2441052      248504      183808     1119480      861748
    Swap:       4063228      866856     3196372
    有人提出【MemTotal = MemFree + buff/cache + slab + 全部进程占用的内存】。这是不对的,原因之一是:进程占用的内存包含了一部分page cache,换句话说,就是进程占用的内存与page cache发生了重叠。比如进程的mmap文件映射同时也统计在page cache中。我们用一个实验来证明,下面的小程序调用mmap()映射了一个大文件,等我们检查内存状态之后,再读取文件使它真正进入内存,我们将最后的内存状态与之前的进行对比:


    #include <sys/mman.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
     
    intmain()
    {
        char*addr,c;
        intfd,i;
        structstatsb;
        size_tlength;
        ssize_ts;
     
        fd=open("/tmp/BIGFILE",O_RDONLY);
        if(fd==-1){
            fprintf(stderr,"open failed\n");
            exit(EXIT_FAILURE);
        }
     
        if(fstat(fd,&sb)==-1)          /* To obtain file size */
        {
            fprintf(stderr,"fstat failed\n");
            exit(EXIT_FAILURE);
        }
     
        length=sb.st_size;
     
        addr=mmap(NULL,length,PROT_READ,MAP_PRIVATE,fd,0);
     
        if(addr==MAP_FAILED){
            fprintf(stderr,"mmap failed\n");
            exit(EXIT_FAILURE);
        }
     
        printf("After check /proc/meminfo and /proc/<pid>/smaps\nPlease press any key to scan the mmap...\n");
        getchar();
     
        for(i=0;i<length;i++){
            c=addr[i];
        }
     
        printf("After check /proc/meminfo and /proc/<pid>/smaps\nPlease press any key to exit...\n");
        getchar();
     
        exit(EXIT_SUCCESS);
    }






    测试结果是这样的:




    // mmap之后,读取文件之前:
    # less /proc/meminfo
    ...
    Cached:          859888kB
    ...
     
    # less /proc/6892/smaps
    ...
    7fab335f8000-7fab35f7a000r--p0000000008:01202                        /tmp/BIGFILE
    Size:              42504kB
    Rss:                  0kB
    Pss:                  0kB
    ...
     
    // 读取文件之后:
    // 注意cache和进程的Rss/Pss同时增大
    # less /proc/meminfo
    ...
    Cached:          902396kB
    ...
     
    # less /proc/6892/smaps
    ...
    7fab335f8000-7fab35f7a000r--p0000000008:01202                        /tmp/BIGFILE
    Size:              42504kB
    Rss:              42504kB
    Pss:              42504kB
    ...
    可以看到,page cache的大小和进程的/RssPss同时变大了,而且增加的大小也吻合,证明进程占用的内存与page cache的统计是有重叠的。

    展开全文
  • csdn lidp http://blog.csdn.net/perfectpdl # desc :get process meminfo every xxx seconds. # author :lidp #!/bin/sh pid=1036 ...# pid = `ps|grep xxxx |awk 'NR==1 {print $1}'` ...# get mem
      csdn lidp  http://blog.csdn.net/perfectpdl
    
    
    
    
    
    # desc  :get process meminfo every xxx seconds.
    # author :lidp
    
    #!/bin/sh
    
    pid=1036
    
    # pid = `ps|grep xxxx |awk 'NR==1 {print $1}'`
    echo $pid
    
    
    # get meminfo every 3 seconds
    interval=3
    
    while true
       do
           DATE=`date +%H:%M:%S-%Y-%m-%d`
           echo $DATE >> proc_memlog.txt
           cat /proc/$pid/status|grep -e VmRSS >> proc_memlog.txt
           echo $blank >> proc_memlog.txt
           sleep $interval
    
       done
    

    展开全文
  • Linux进程内存分析和内存泄漏定位

    千次阅读 2017-08-21 10:35:10
    linux本身提供了一些工具方便我们达成这些需求,查看进程实时资源top工具,更详细的进程内存堆栈情况,pmap工具,Linux进程运行时状态信息也会保存在proc目录下,相应进程ID目录下,这里有很丰富的信息,先讨论进程...
  • linux 进程内存解析

    千次阅读 2011-06-02 10:35:00
    之前我所了解的linux进程的地址空间的布局的知识,是从APUE第2版的P430得来的,之后上网查了一些资料,大概弄了明白。一个linux进程分为几个部分(从一个进程的地址空间的低地址向高地址增长):1.text段,就是存放...
  • linux 进程占用内存查询

    万次阅读 2014-04-15 17:58:51
    ”导致大多数人认为许多Linux应用程序,特别是KDE或GNOME程序都象ps报告一样臃肿...【51CTO.com独家译文】本文是为那些经常疑惑的人准备的,“为什么一个简单的KDE文本编辑器要占用25M内存?”导致大多数人认为许多...
  • 查看LINUX进程内存占用情况

    万次阅读 2018-01-05 14:38:27
    可以选择按进程查看或者按用户查看,如想查看oracle用户的进程内存使用情况的话可以使用如下的命令:  (1)top  top命令是Linux下常用的性能分析工具,能够实时显示系统中各个进程的资源占用状况,类似于...
  • pczou的linux进程内存解析

    千次阅读 2010-04-30 15:17:00
    pczou的linux进程内存解析2006年12月11日 wgzhao 发表评论 阅读评论 2月份的时候贴过一篇关于如何理解Linux内存的帖子。今天pczou献上了一道大餐–进程的内存使用解析。讲得非常详细,先剽窃过来,呵呵。Linux下如果...
  • 查看LINUX进程内存情况的命令

    千次阅读 2014-07-28 10:52:07
    要对进程进行监测和控制,首先必须要了解当前进程的情况,也就是需要查看当前进程,而ps命令就是最基本同时也是非常强大的进程查看命令。使用该命令能确定有哪些进程正在运行和运行的状态、进程是否结束、进程有没有...
  • Linux内存点滴 用户进程内存空间

    千次阅读 2013-07-12 15:03:35
    Linux操作系统的内存使用方法详细解析  出处信息 我是一名程序员,那么我在这里以一个程序员的角度来讲解Linux内存的使用。 一提到内存管理,我们头脑中闪出的两个概念,就是虚拟内存,与物理内存。这...
  • linux 进程内存占用高分析

    万次阅读 2018-06-11 16:19:36
    通过free命令可以查看系统内存使用情况: free -m total used free shared buff/cache available Mem: 7983 2427 5155 26 400 5272 Swap: ...
  • 1、安装 sudo apt-get install sysstat 2、使用 /usr/local/bin/pidstat -r -u -d -w -h -p ...-d #显示I/O统计信息(须内核2.6.20及以后) PID #进程号 kB_rd/s #每秒此进程从磁盘读取的千字节数 kB_wr...
  • 进程内存消耗分析 总体消耗 堆内存 静态数据区和只读数据区 栈内存 free命令的结果 使用busybox-1.31.0中的free命令(procps/free.c实现,主要从/proc/meminfo文件和sysinfo()系统调用中获得),命令执行结果中...
  • 进程内存状态 ,我们可以通过/proc或者常规命令比如top或ps得到它。 语法或用法 #pmap PID 或者 #pmap [options] PID  在输出中它显示全部的地址,kbytes,mode还有mapping。 选项 ...
  • Linux如何统计进程的CPU利用率

    千次阅读 2018-06-28 09:01:09
    1. 如何统计进程CPU利用率1.0 概述在Linux的/proc文件系统,可以看到自启动时候开始,所有CPU消耗的时间片;对于个进程,也可以看到进程消耗的时间片。这是一个累计值,可以"非阻塞"的输出。获得一定时间...
  • 聊聊 Linux内存统计

    2020-01-08 20:31:21
    写在前面本文主要分析 Linux 系统内存统计的一些指标以及进程角度内存使用监控的一些方法。开始阅读这篇文章前,请先简单阅读下面的几篇文章。《进程眼中的线性地址空间》《线程眼中的线性地址...
  • 在系统维护的过程中,随时可能有需要查看 CPU 使用率,并根据相应信息分析系统状况的需要。在 CentOS 中,可以通过 top 命令来查看 CPU 使用状况。运行 top 命令后,CPU 使用状态会以...top命令是Linux下常用的性能...
  • 参考 :https://www.cnblogs.com/zhuiluoyu/p/6154898.html ps aux --sort -rss或者:https://www.cnblogs.com/sparkbj/p/6148817.htmlLinux下如何查看哪些进程占用的CPU内存资源最多linux下获取占用CPU资源最多的10...
  • 在产品的开发中,通过对当前系统消耗内存总量的统计,可以对产品所需内存总量进行精确的评估,从而选择合适的内存芯片与大小,降低产品的成本。在遇到内存泄露类问题时,经常会对此束手无策,本文通过对proc下进程...
  • 0x01 缘由  当将生产环境换为64bit后,系统内存的问题全部显现,内存耗尽、内存占用大,导致内存耗尽,吃掉交换分区内存,然后系统卡、卡、卡...... linux c 编程资源限制:  API:  能够通过函数get
  • linux 查看进程/内存/磁盘空间

    千次阅读 2012-12-13 09:20:19
    原文地址:http://blog.163.com/bobile45@126/blog/static/960619922012542475706/   1. ps 命令用于查看当前正在运行的进程。 ... 表示查看所有进程里CMD是java的进程信息  ps -aux | grep ja
  • Linux上查看某个进程内存占用情况

    千次阅读 2017-03-07 12:19:25
    Linux 上进行开发和运营维护的时候,免不了要查看某一个程序所占用内存的情况。有很多个命令都可以达到我们的需求,这里给大家列举几个:  1:top -p pid 查看程序的情况  2:ps -aux | grep process...
  • Linux进程通信之POSIX共享内存

    万次阅读 2013-08-13 01:09:19
    前面已经讨论过Linux下个各种进程间的通信方式:管道,FIFO,消息队列,他们的共同特点就是通过内核来进行通信(假设POSIX消息队列也是在内核中实现的,因为POSIX标准并没有限定它的实现方式)。向管道,FIFO,消息...
  • linux 下 取进程占用 cpu 最高的前10个进程 ps aux | head -1 ; ps aux | grep -v PID | sort...linux 下 取进程占用 内存mem 最高的前10个进程 ps aux | head -1 ; ps aux | grep -v PID | sort -rn -k +4 | head ...
  • 计算linux系统所有进程占用的内存之和 需求分析: 先将所有进程使用的内存统计出来,然后在将这些内存相加就是内存之和 统计所有进程使用的内存: ps aux 命令可以查看这些内存,第六列 RSS 物理内存 ps aux |...
  • linux内存管理--进程内存中的分布

    千次阅读 多人点赞 2013-09-26 10:51:43
    一、进程内存  所有进程(执行的程序)都必须占用一定数量的内存,它或是用来存放从磁盘载入的程序代码,或是存放取自用户输入的数据等等。不过进程对这些内存的管理方式因内存用途不一而不尽相同,有些内存是...
  • LINUX检查一个进程内存增长的脚本

    千次阅读 多人点赞 2019-01-07 09:37:05
    内存泄露很难查。  1、内存有没有泄露?  2、内存在哪里泄露?  为了解决第一个问题,吾绞尽脑汁,写了一个脚本,检查特定程序的内存增长。即只要增长就会输出。分享出来供大家参考。 # ps -A | grep ${...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 96,388
精华内容 38,555
关键字:

linux统计进程内存

linux 订阅