精华内容
下载资源
问答
  • 查看GPU服务器内存利用率和GPU利用率命令:nvidia-smi
    2020-07-25 00:26:29

    运行之前要先确保服务器已经配置好相关环境,然后可以输入命令nvidia-smi查看一下GPU的使用情况,下图输入命令后的结果,主要看内存利用率(第二列)和GPU利用率(第三列),图中因为没有程序在运行,所以GPU的利用率为0%。
    在这里插入图片描述
    在这里插入图片描述

    如果服务器中有多个GPU,而只想用某一个GPU运行程序,可以设置CUDA_VISIBLE_DEVICES的值等于某个空闲GPU的序号,假设要使用GPU运行test.py,输入如下:

    $ CUDA_VISIBLE_DEVICES=0 python test.py
    

    对文件的其他操作即在Linux下的操作,输入相关命令即可

    更多相关内容
  • 16prometheus监控pod集的内存CPU使用
  • 计算cpu利用率内存利用率

    万次阅读 2015-01-20 17:08:29
    Linux 下CPU、内存利用率--计算(二) 当需要频繁地获取,可以选择这种方法。 1、原理 (1) CPU利用率 在Linux下,CPU利用率分为用户态,系统态和空闲态,分别表示CPU处于用户态执行的时间,系统...
      
    Linux CPU、内存利用率--计算(二)
    当需要频繁地获取,可以选择这种方法。
    1、原理
    (1)   CPU利用率
    Linux 下, CPU 利用率分为用户态,系统态和空闲态,分别表示 CPU 处于用户态执行的时间,系统内核执行的时间,和空闲系统进程执行的时间,三者之和就是 CPU 的总时间,当没有用户进程、系统进程等需要执行的时候, CPU 就执行系统缺省的空闲进程。从平常的思维方式理解的话, CPU 的利用率就是非空闲进程占用时间的比例,即 CPU 执行非空闲进程的时间  CPU 总的执行时间。
    Linux 系统中, CPU 时间的分配信息保存在 /proc/stat 文件中,利用率的计算应该从这个文件中获取数据。文件的头几行记录了每个 CPU 的用户态,系统态,空闲态等状态下分配的时间片(单位是 Jiffies ),这些数据是从 CPU 加电到当前的累计值。常用的监控软件就是利用 /proc/stat 里面的这些数据来计算 CPU 的利用率的。
    不同版本的 linux /proc/stat 文件内容不一样,以 Linux 2.6 来说, /proc/stat 文件的内容如下:
     
    cpu 2032004 102648 238344 167130733 758440 15159 17878 0
    cpu0 1022597 63462 141826 83528451 366530 9362 15386 0
    cpu1 1009407 39185 96518 83602282 391909 5796 2492 0
    intr 303194010 212852371 3 0 0 11 0 0 2 1 1 0 0 3 0 11097365 0 72615114 6628960 0 179 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
    ctxt 236095529
    btime 1195210746
    processes 401389
    procs_running 1
    procs_blocked 0
     
    第一行的数值表示的是 CPU 总的使用情况,所以我们只要用第一行的数字计算就可以了。下表解析第一行各数值的含义:
    参数 解析(单位:jiffies
    user (2032004) 从系统启动开始累计到当前时刻,用户态的CPU时间,不包含 nice值为负进程。
    nice (102648) 从系统启动开始累计到当前时刻,nice值为负的进程所占用的CPU时间
    system (238344) 从系统启动开始累计到当前时刻,核心时间
    idle (167130733) 从系统启动开始累计到当前时刻,除硬盘IO等待时间以外其它等待时间
    iowait (758440) 从系统启动开始累计到当前时刻,硬盘IO等待时间
    irq (15159) 从系统启动开始累计到当前时刻,硬中断时间
    softirq (17878) 从系统启动开始累计到当前时刻,软中断时间
     
     
    因为 /proc/stat 中的数值都是从系统启动开始累计到当前时刻的积累值,所以需要在不同时间点 t1 t2 取值进行比较运算,当两个时间点的间隔较短时,就可以把这个计算结果看作是 CPU 的即时利用率。
     
    CPU的即时利用率的计算公式:
    CPU t1 t2 时间段总的使用时间  = ( user2+ nice2+ system2+ idle2+ iowait2+ irq2+ softirq2) - ( user1+ nice1+ system1+ idle1+ iowait1+ irq1+ softirq1)
    CPU t1 t2 时间段空闲使用时间  = (idle2 - idle1)
    CPU t1 t2 时间段即时利用率  =  1 - CPU 空闲使用时间  / CPU 总的使用时间
     
     
    2)内存利用率
    计算内存利用率需要从 /proc/meminfo 文件中取相应数据,文件内容如下:
    MemTotal:      1024008 kB
    MemFree:         18448 kB
    Buffers:         12664 kB
    Cached:         282500 kB
    SwapCached:        716 kB
    Active:         816124 kB
    Inactive:        52516 kB
    HighTotal:      122500 kB
    HighFree:          304 kB
     
    … …
     
    MemTotal 数值表示内存总量, MemFree 数值表示空余数量。
    所以内存的即时利用率计算公式
    (MemTotal - MemFree)/ MemTotal
     
     
    2、实现
      这个例子适合于linux内核是2.6版本。Linux的版本问题请参照Linux 下CPU、内存利用率--获取(一)
     

    import  java.io.BufferedReader;
    import  java.io.File;
    import  java.io.FileInputStream;
    import  java.io.IOException;
    import  java.io.InputStreamReader;
    import  java.util.StringTokenizer;


    public   class  MonitorUsageThread  extends  Thread {
        
        
    private final int frequency;//MS
        private static final File memFile = new File("/proc/meminfo");
        
    private static final File statFile = new File("/proc/stat");
        
    private static BufferedReader brMem ;
        
    private static BufferedReader brStat ;
        
    private static InputStreamReader isr = null;
        
        
    private static float cpuUsage;
        
    private static float memUsage;
        
        
    private static boolean on = true;
        
    public MonitorUsageThread(int frequency){
            
    this.frequency = frequency;
        }

        
        
        
    public void run(){
            System.out.println(
    "MonitorUsageThread start run ..................... on: "+on);
            String str 
    = null;
            StringTokenizer tokenMem 
    = null;
            
    int memTotal = 0;
            
    int memFree = 0;
            
    int userStart,niceStart,sysStart,idleStart,iowaitStart,hardirpStart,softirpStart,userEnd,niceEnd,sysEnd,idleEnd,iowaitEnd,hardirpEnd,softirpEnd;
            
    try {
                isr 
    = new InputStreamReader(new FileInputStream(statFile));
                brStat 
    = new BufferedReader(isr);
                StringTokenizer tokenStat 
    = new StringTokenizer(brStat.readLine());
                tokenStat.nextToken();
                userStart 
    = Integer.parseInt(tokenStat.nextToken());
                niceStart 
    = Integer.parseInt(tokenStat.nextToken());
                sysStart 
    = Integer.parseInt(tokenStat.nextToken());
                idleStart 
    = Integer.parseInt(tokenStat.nextToken());
                iowaitStart 
    = Integer.parseInt(tokenStat.nextToken());
                hardirpStart 
    = Integer.parseInt(tokenStat.nextToken());
                softirpStart 
    = Integer.parseInt(tokenStat.nextToken());
                Thread.sleep(frequency);
                
    while(on){
                    isr 
    = new InputStreamReader(new FileInputStream(statFile));
                    brStat 
    = new BufferedReader(isr);
                    tokenStat 
    = new StringTokenizer(brStat.readLine());
                    tokenStat.nextToken();
                    userEnd 
    = Integer.parseInt(tokenStat.nextToken());
                    niceEnd 
    = Integer.parseInt(tokenStat.nextToken());
                    sysEnd 
    = Integer.parseInt(tokenStat.nextToken());
                    idleEnd 
    = Integer.parseInt(tokenStat.nextToken());
                    iowaitEnd 
    = Integer.parseInt(tokenStat.nextToken());
                    hardirpEnd 
    = Integer.parseInt(tokenStat.nextToken());
                    softirpEnd 
    = Integer.parseInt(tokenStat.nextToken());
                    

                    
    int CPUEnd = userEnd+niceEnd+sysEnd+idleEnd+iowaitEnd+hardirpEnd+softirpEnd;
                    
    int CPUStart = userStart+niceStart+sysStart+idleStart+iowaitStart+hardirpStart+softirpStart;
                    System.out.println(
    "idleEnd:"+idleEnd+" , idleStart:"+idleStart+"   ,CPUEnd:"+CPUEnd+" , CPUStart:"+CPUStart);
                    
                    cpuUsage 
    = 1- (float)(idleEnd - idleStart) / (float)(CPUEnd - CPUStart);// cpu usage

                    
    //Gets memory information
                    isr = new InputStreamReader(new FileInputStream(memFile));
                    brMem 
    = new BufferedReader(isr);
                    
                    str 
    = brMem.readLine();
                    tokenMem 
    = new StringTokenizer(str);
                    tokenMem.nextToken();
                    memTotal 
    = Integer.parseInt(tokenMem.nextToken());
                    
                    str 
    = brMem.readLine();
                    tokenMem 
    = new StringTokenizer(str);
                    tokenMem.nextToken();
                    memFree 
    = Integer.parseInt(tokenMem.nextToken());
                            
                    System.out.println(
    "MemTotal:"+memTotal+" , MemFree:"+memFree);
                    memUsage 
    = (float)(memTotal-memFree) / (float)memTotal;// memory usage 
                    
                    userStart 
    = userEnd;
                    niceStart 
    = niceEnd;
                    sysStart 
    = sysEnd;
                    idleStart 
    = idleEnd;
                    iowaitStart 
    = iowaitEnd;
                    hardirpStart 
    = hardirpEnd;
                    softirpStart 
    = softirpEnd;

                    System.out.println(
    "Rate of CPU usage is "+cpuUsage+" , and the memory's is "+memUsage+"  ");
                    Thread.sleep(frequency);
    //
                }

                    
                    
            }
     catch (IOException ioe) {
                System.out.println(ioe.getMessage());
            }
     catch (InterruptedException ie) {
                System.out.println(ie.getMessage());
            }
     finally{
                freeResource();
            }


        }

                  
        
        
    private static void freeResource(){
            
    try{
                
    if(isr!=null)
                    isr.close();
                
    if(brMem!=null)
                    brMem.close();
                
    if(brStat!=null)
                    brStat.close();
            }
    catch(IOException ioe){
                System.out.println(ioe.getMessage());
            }

        }

        
        
    public static float getCPUUsage(){
            
    return cpuUsage;
        }

        
        
        
    public static float getMemoryUsage(){
            
    return memUsage;
        }

        
        
    public static void stopMonitor(){
            on 
    = false;
            freeResource();
        }

        
        
        
        
    public static void main(String[] args){
            MonitorUsageThread thread 
    = new MonitorUsageThread(2000);
            thread.start();
            
    try{
                Thread.sleep(
    10000);//MS
            }
    catch(InterruptedException ie){
                ie.printStackTrace();
            }

            System.out.println();
            System.out.println(
    "-------------CPU usage: "+getCPUUsage());
            System.out.println(
    "-------------Memory usage: "+getMemoryUsage());
            
            
    try{
                Thread.sleep(
    5000);//MS
            }
    catch(InterruptedException ie){
                ie.printStackTrace();
            }

            System.out.println();
            System.out.println(
    "-------------CPU usage: "+getCPUUsage());
            System.out.println(
    "-------------Memory usage: "+getMemoryUsage());
            
            
            thread.stopMonitor();
            System.exit(
    0);
        }

        
    }


    展开全文
  • 即,每个进程申请使用内存占总内存的百分比比较接近实际的数据为从千分之几到百分之十几,在这里,我们取从0.02%到15%。 但是为了说明情况,在实验中,我将申请内存占总内存的比率分为六个区间,分别为:0.02%...

        参考windows任务管理器中内存占用的情况,在256M的总内存中,各个进程所占的内存从几十K到几十M不等,基本可以看成是均匀分布。即,每个进程申请使用的内存占总内存的百分比比较接近实际的数据为从千分之几到百分之十几,在这里,我们取从0.02%15%

        但是为了说明情况,在实验中,我将申请内存占总内存的比率分为六个区间,分别为:0.02%——2%0.02%——8%0.02%——15%0.02%——25%0.02%——40%0.02%——60%。对于四种不同的分配策略,分别考察从区间0.02%——2%变化到0.02%——60%时内存平均利用率的变化情况。可以得出较一般的结论。

    实验结果如下:

    将实验结果用图示的方法表现出来如下图所示:

        从这张内存分配策略实验比较图可以看出,总体来说,仅就内存平均利用率这一个指标来看,best-fit > first-fit > next-fit > worst-fit。且随着申请内存占总内存比率的增大,各种分配策略的内存平均利用率趋于一致。从各种分配策略单独来看,随着申请内存占总内存比率的增大,各种分配策略的内存平均利用率都有所下降,但下降的速率有所差别。相比较而言,平均利用率最大的best-fit下降的幅度最大,而平均利用率最小的worst-fit下降的幅度最小,first-fitnext-fit居于它们之间。

        总体结论:内存平均利用率的好坏不仅和内存的分配策略有关,还和进程申请内存占总内存的平均比率有关。在同等条件下,若仅考虑内存分配策略,则best-fit > first-fit > next-fit > worst-fit,若仅考虑申请内存占总内存的比率,则随着申请内存占总内存比率的增大,内存平均使用率下降,下降的斜率best-fit > first-fit > next-fit > worst-fit

    附:

    对程序的一点说明:

    程序中,用两个数据结构来维护内存使用状况,分别是USED_LINKFREE_LINK。链表中的每一项都是一个BLOCK_NODE,其定义为:

    typedef struct block{
     //int blockId;
     int startPosition;
     int endPosition;
     int length;
     struct block *next;
    } BLOCK_NODE, *pBLOCK_NODE;

    程序中,模拟内存的大小为256M,即

    #define MEM_SIZE 268435456 //256M

    内存初始化,申请内存以及释放内存的函数分别定义为:

    void mem_init();

    int mem_request(int size, STRATEGY strategy);

    bool mem_release(int startPosition);

    其中,STRATEGY对应于四种不同的分配策略:

    typedef enum {FIRST_FIT, NEXT_FIT, BEST_FIT, WORST_FIT} STRATEGY;

    完整的源代码如下:

    mem.h

    #ifndef _MEM_H
    #define _MEM_H

    #include <stdio.h>

    //#define MEM_SIZE 1024   //1K
    //#define MEM_SIZE 1048576  //1M
    #define MEM_SIZE 268435456 //256M

    typedef struct block{
     //int blockId;
     int startPosition;
     int endPosition;
     int length;
     struct block *next;
    } BLOCK_NODE, *pBLOCK_NODE;

    typedef struct {
     pBLOCK_NODE head;
     pBLOCK_NODE tail;
     int blockNum;
    }USED_LINK, FREE_LINK;

    typedef enum {FIRST_FIT, NEXT_FIT, BEST_FIT, WORST_FIT} STRATEGY;

    void mem_init();
    int mem_request(int size, STRATEGY strategy);
    bool mem_release(int startPosition);

    #endif

     

    mem.cpp

    #include <stdio.h>
    #include <memory.h>
    #include "mem.h"

    USED_LINK used_link;
    FREE_LINK free_link;

    pBLOCK_NODE fromThis = free_link.head;
    //char memory[MEM_SIZE];

    //内存初始化。
    void mem_init() {
     //memset(memory, 0, MEM_SIZE);

     //使用链表置空。
     used_link.head = NULL;
     used_link.tail = NULL;
     used_link.blockNum = 0;

     //空闲连标初始为一个完整的空闲块,块大小为整个内存区。
     pBLOCK_NODE tmp = new BLOCK_NODE;
     tmp->startPosition = 0;
     tmp->endPosition = MEM_SIZE - 1;
     tmp->length = MEM_SIZE;
     tmp->next = NULL;

     free_link.head = tmp;
     free_link.tail = tmp;
     free_link.blockNum = 1;
    }

    //内存请求,按一定的分配策略分配,
    //并返回分配后内存的首地址。
    int mem_request(int size, STRATEGY strategy) {
     //若size小于等于零或者大于总内存大小,则错误返回。
     if (size <= 0 || size > MEM_SIZE) {
      //printf("Memory size error!/n");
      return -1;
     }

     pBLOCK_NODE temp = NULL;

     //first_fit
     //搜索能够满足请求的内存块。
     //若没有满足要求的内存块,则返回-1。
     if (strategy == FIRST_FIT) {
      temp = free_link.head;
      while (free_link.blockNum > 0) {
       if (temp == NULL) {
        break;
       } else if (temp->length >= size) {
        break;
       } else {
        temp = temp->next;
       }
      }
     }

     //next_fit strategy
     if (strategy == NEXT_FIT) {
      int blockNum = free_link.blockNum;
      for (int i = 0; i < blockNum; i++) {
       if (fromThis == NULL) {
        fromThis = free_link.head;
       }
       if (fromThis->length >= size) {
        temp = fromThis;
        fromThis = fromThis->next;
        break;
       } else {
        fromThis = fromThis->next;
       }
      }
     }

     //best_fit
     if (strategy == BEST_FIT) {
      int t = MEM_SIZE + 1;
      pBLOCK_NODE tp = free_link.head;
      while (free_link.blockNum > 0) {
       if (tp == NULL) {
        break;
       } else if (tp->length >= size) {
        if (tp->length < t) {
         temp = tp;
         t = tp->length;
        }
        tp = tp->next;
       } else {
        tp = tp->next;
       }
      }
     }

     //worst_fit strategy
     if (strategy == WORST_FIT) {
      int t = 0;
      pBLOCK_NODE tp = free_link.head;
      while (free_link.blockNum > 0) {
       if (tp == NULL) {
        break;
       } else if (tp->length >= size) {
        if (tp->length > t) {
         temp = tp;
         t = tp->length;
        }
        tp = tp->next;
       } else {
        tp = tp->next;
       }
      }
     }

     if (temp == NULL) {
      //printf("Alloc Failed!/n");
      return -1;
     } else {
      //若存在满足要求的内存块,则创建新的内存块。
      pBLOCK_NODE newNode = new BLOCK_NODE;
      newNode->startPosition = temp->startPosition;
      newNode->endPosition = newNode->startPosition + size - 1;
      newNode->length = size;
      newNode->next = NULL;

      //将新分配的内存块信息插入到使用链表中。
      if (used_link.blockNum == 0) {
       used_link.head = newNode;
       used_link.tail = newNode;
       used_link.blockNum = 1;
      } else if (used_link.blockNum >= 1) {
       //按内存块首地址递增的方式插入。
       pBLOCK_NODE preNode = NULL;
       pBLOCK_NODE curNode = used_link.head;
       if (newNode->startPosition < curNode->startPosition) {
        newNode->next = used_link.head;
        used_link.head = newNode;
        used_link.blockNum++;
       } else {
        while (curNode->startPosition < newNode->startPosition) {
         preNode = curNode;
         curNode = curNode->next;
         if (curNode == NULL) {
          break;
         }
        }
        if (curNode == NULL) {
         used_link.tail->next = newNode;
         used_link.tail = newNode;
         used_link.blockNum++;
        } else {
         newNode->next = curNode;
         preNode->next = newNode;
         used_link.blockNum++;
        }
       }
      }

      //修改空闲链表中可用内存块的信息。
      if (temp->length == size) {
       if (temp == free_link.head) {
        free_link.head = temp->next;
        if (free_link.head == NULL) {
         free_link.tail = NULL;
        }

        delete temp;
        free_link.blockNum--;
       } else {
        pBLOCK_NODE preNode = free_link.head;
        pBLOCK_NODE curNode = free_link.head->next;
        while (temp != curNode) {
         preNode = curNode;
         curNode = curNode->next;
        }
        if (curNode == free_link.tail) {
         free_link.tail = preNode;
         preNode->next = NULL;
        } else {
         preNode->next = curNode->next;
        }

        delete temp;
        free_link.blockNum--;
       }
      } else if (temp->length > size) {
       temp->startPosition += size;
       temp->length -= size;
      }

      //返回分配成功后的首地址。
      return newNode->startPosition;
     }
    }

    bool mem_release(int startPosition) {
     pBLOCK_NODE release_target = used_link.head;
     pBLOCK_NODE preNode = NULL;

     //此时使用链表为空。
     if (release_target == NULL) {
      printf("No such alloced memory!/n");
      return false;
     }
     //搜索需要释放的内存块。
     while (release_target->startPosition != startPosition) {
      preNode = release_target;
      release_target = release_target->next;
      if (release_target == NULL) {
       break;
      }
     }

     //修改使用链表中内存使用信息。删除释放内存的信息结点。
     if (release_target == NULL) {
      printf("No such alloced memory!/n");
      return false;
     } else if (release_target == used_link.head && release_target == used_link.tail) {
      used_link.head = NULL;
      used_link.tail = NULL;
      used_link.blockNum--;
     } else if (release_target == used_link.head) {
      used_link.head = used_link.head->next;
      used_link.blockNum--;
     } else if (release_target == used_link.tail) {
      preNode->next = release_target->next;
      used_link.tail = preNode;
      used_link.blockNum--;
     } else {
      preNode->next = release_target->next;
      used_link.blockNum--;
     }

     //修改空闲链表信息,将释放后可重新使用的内存块信息写入空闲链表,
     //并进行必要的合并。
     pBLOCK_NODE insertBefore = free_link.head;
     preNode = NULL;
     if (free_link.head == NULL) {
      free_link.head = release_target;
      free_link.tail = release_target;
      release_target->next = NULL;
      free_link.blockNum++;
     } else if (release_target->startPosition < free_link.head->startPosition) {
      if (release_target->endPosition + 1 == free_link.head->startPosition) {
       free_link.head->startPosition = release_target->startPosition;
       free_link.head->length += release_target->length;
       delete release_target;
      } else {
       release_target->next = free_link.head;
       free_link.head = release_target;
       free_link.blockNum++;
      }
     } else {
      while (insertBefore->startPosition < release_target->startPosition) {
       preNode = insertBefore;
       insertBefore = insertBefore->next;
       if (insertBefore == NULL) {
        break;
       }
      }
      if (insertBefore == NULL) {
       if (release_target->startPosition - 1 == preNode->endPosition) {
        preNode->endPosition = release_target->endPosition;
        preNode->length += release_target->length;
        delete release_target;
       } else {
        preNode->next = release_target;
        free_link.tail = release_target;
        release_target->next = NULL;
        free_link.blockNum++;
       }
      } else {
       if (release_target->startPosition - 1 == preNode->endPosition
        && release_target->endPosition + 1 == insertBefore->startPosition) {
        if (insertBefore == free_link.tail) {
         preNode->endPosition = insertBefore->endPosition;
         preNode->length += (release_target->length + insertBefore->length);
         preNode->next = insertBefore->next;

         if (fromThis == insertBefore) {
          fromThis = preNode;
         }

         delete insertBefore;
         delete release_target;
         free_link.tail = preNode;
         free_link.blockNum--;
        } else {
         preNode->endPosition = insertBefore->endPosition;
         preNode->length += (release_target->length + insertBefore->length);
         preNode->next = insertBefore->next;

         if (fromThis == insertBefore) {
          fromThis = preNode;
         }

         delete insertBefore;
         delete release_target;
         free_link.blockNum--;
        }
       } else if (release_target->startPosition - 1 == preNode->endPosition) {
        preNode->endPosition = release_target->endPosition;
        preNode->length += release_target->length;
        delete release_target;
       } else if (release_target->endPosition + 1 == insertBefore->startPosition) {
        insertBefore->startPosition = release_target->startPosition;
        insertBefore->length += release_target->length;
        delete release_target;
       } else {
        release_target->next = preNode->next;
        preNode->next = release_target;
        free_link.blockNum++;
       }
      }
     }

     return true;
    }

     

    allocate.cpp

    #include <stdio.h>
    #include <time.h>
    #include <stdlib.h>
    #include "mem.h"

    #define ROUNDS 1000000
    extern FREE_LINK free_link;
    extern USED_LINK used_link;

    int computeSize(double rangeLow, double rangeHigh);
    double computeFraction(STRATEGY strategy, double rangeLow, double rangeHigh);
    double averageRand(double min, double max);
    void computeAndPrint(double rangeLow, double rangeHigh);

    main() {
     mem_init();
     srand((unsigned)time(NULL));

     printf("申请内存占总内存比率为0.02%%--2%%时:/n");
     computeAndPrint(0.0002, 0.02);
     printf("/n申请内存占总内存比率为0.02%%--8%%时:/n");
     computeAndPrint(0.0002, 0.08);
     printf("/n申请内存占总内存比率为0.02%%--15%%时:/n");
     computeAndPrint(0.0002, 0.15);
     printf("/n申请内存占总内存比率为0.02%%--25%%时:/n");
     computeAndPrint(0.0002, 0.25);
     printf("/n申请内存占总内存比率为0.02%%--40%%时:/n");
     computeAndPrint(0.0002, 0.40);
     printf("/n申请内存占总内存比率为0.02%%--60%%时:/n");
     computeAndPrint(0.0002, 0.60);

     return 0;
    }

    void computeAndPrint(double rangeLow, double rangeHigh) {
     printf("first_fit内存平均利用率:/t%f/n", computeFraction(FIRST_FIT, rangeLow, rangeHigh));
     printf("next_fit内存平均利用率:/t%f/n", computeFraction(NEXT_FIT, rangeLow, rangeHigh));
     printf("best_fit内存平均利用率:/t%f/n", computeFraction(BEST_FIT, rangeLow, rangeHigh));
     printf("worst_fit内存平均利用率:/t%f/n", computeFraction(WORST_FIT, rangeLow, rangeHigh));
    }

    double computeFraction(STRATEGY strategy, double rangeLow, double rangeHigh) {
     int pointerTemp = -1;
     double fraction = 0;
     for (int i = 0; i < ROUNDS; i++) {
      int requestSize = 0;
      do {
       requestSize = computeSize(rangeLow, rangeHigh);
       pointerTemp = mem_request(requestSize, strategy);
      } while (pointerTemp != -1);

      int temp = 0;
      pBLOCK_NODE nodeTemp = free_link.head;
      while (nodeTemp != NULL) {
       temp += nodeTemp->length;
       nodeTemp = nodeTemp->next;
      }
      fraction += (MEM_SIZE - (double)temp)/MEM_SIZE;

      if (used_link.blockNum != 0) {
       int releaseBlock = rand() % used_link.blockNum;
       nodeTemp = used_link.head;
       for (int j = 0; j < releaseBlock; j++) {
        nodeTemp = nodeTemp->next;
       }
       mem_release(nodeTemp->startPosition);
      }
     }
     fraction /= ROUNDS;

     //printf("Average used fraction: %f/n", fraction);
     return fraction;
    }

    int computeSize(double rangeLow, double rangeHigh) {
     return (int)(averageRand(rangeLow, rangeHigh)*MEM_SIZE);
    }

    double averageRand(double min, double max) {
     int minInteger = (int)(min*10000);
     int maxInteger = (int)(max*10000);
     int diffInteger = maxInteger - minInteger;
     double randInteger = (double)rand()/RAND_MAX;
     int resultInteger = (int) ( randInteger * diffInteger + minInteger );

     return resultInteger/10000.0;
    }

    展开全文
  • Hadoop集群上运行有多道MapReduce Job,到底每个Job消费集群计算资源(CPU,内存)的情况如何,通常我们是不知道的。这节来探讨下如果想获得这些信息,应该怎样做。   每个Job在运行时是散布在TaskTracker上,由...
    Hadoop集群上运行有多道MapReduce Job,到底每个Job消费集群计算资源(CPU,内存)的情况如何,通常我们是不知道的。这节来探讨下如果想获得这些信息,应该怎样做。 

        每个Job在运行时是散布在TaskTracker上,由不同的JVM来执行。所以这个问题归根结底就是想获取每个运行task的JVM对资源的消费情况。对于这种获取分布式环境数据的例子,就可以采用MapReduce框架自带的Counter机制,由它来采集各JVM运行期的实时数据,然后在Job结束后,做最终分析。 

    这项任务的意义在哪里? 
        正常情况下,Job会因为数据范围、服务的应用、数据量的大小及MapReduce逻辑的复杂程度等因素而被定义为不同的类别。当类别的概念形成后,我们就想知道每个类别Job对集群资源的使用情况是否符合预期,如果可以获得这些数据,就可以根据资源使用情况对Job的执行时间做相应的调整,以避免对其它Job的影响。 

    数据采集什么时候开始与结束? 
        我们的目标是分析每个子JVM的资源消耗情况,就应该在子JVM开始运行时介入收集。站在MapReduce框架外,只有一个地方可以作为介入点:Mapper和Reducer的setup方法。它的参数是task运行期Context,可以很方便地调用Counter。那我们的入口就可以像这样
     

    Java代码   收藏代码
    1. public class ResourceCollectMapper<KEYIN, VALUEIN, KEYOUT, VALUEOUT>  
    2.                             extends Mapper<KEYIN, VALUEIN, KEYOUT, VALUEOUT> {  
    3.   
    4.     ChildJVMResourceCollector collector = null;  
    5.     public void setup(Context context) {  
    6.         collector = new ChildJVMResourceCollector(context);  
    7.         collector.start();  
    8.     }  
    9.       
    10. }  


         资源收集器是一个独立线程,在setup方法中启动,在cleanup方法调用时结束。本来整个task的执行过程就包含在setup与cleanup之间,所以我们完全有机会收集这个过程中的资源利用情况。 

    如何获取运行task的JVM pid? 
        运行task的子JVM是由TaskTracker创建的,对用户完全透明。但幸运的是,TaskTrack在创建这个子JVM时,把它的pid作为参数传给了子JVM。获取的方式如下
     
    Java代码   收藏代码
    1. private String getChildJVMPid() {  
    2.     String pid = "";  
    3.     if (!Shell.WINDOWS) {  
    4.         pid = System.getenv().get("JVM_PID");  
    5.     }  
    6.     return pid;  
    7. }  


    怎样根据pid获取系统级的资源使用率? 
        得到当前子JVM的进程号后,就能用这个进程号查询Linux系统当前进程的资源使用情况。查询的方式网上很多资料都有说明
     

     

         上图是通过ps命令查询某个进程的CPU与内存使用情况的截图。其它相似的查询方式大家可以自行实验 
        如果采用上述的linux命令,就需要分开组装,并调用Hadoop提供的Shell组件。
     
    Java代码   收藏代码
    1. String[] queryCommand = new String[]{"ps""-o""%cpu,%mem", pid};  
    2. String result = Shell.execCommand(queryCommand);  

    返回的查询结果是一个字符串,解析字符串,拿到想要的结果,以特定的key把结果存入Counter中(当然获取次数也需要收集,在Counter中由独立key标识),这样我们的一次数据获取过程就结束了。

    最终怎样分析? 
        在Job结束后,根据特定的key获取相应的数据,然后除以获取次数,就是平均的CPU与内存使用率。 

    要注意的情况是? 
        在这个过程中需要注意有两个地方: 
        1. 尽量让获取资源的线程不要占用太多的执行时间,每隔一段时间启用一次,减少对正常task执行的影响; 
        2. 如果遇到某个Job的多个task共用一个子JVM的情况(MapReduce优化的一点,减少频繁创建/销毁JVM的代价),就需要确保在当前task的cleanup方法中一定让获取资源的线程终结掉。这个线程包含着task运行期的Context,如果是Map task的话,那个默认100MB的内存缓冲区也在其中,可能会有OOM问题而影响下一个task的创建过程。
    展开全文
  • top 命令2、vmstat3、sar4、mpstat5、iostat二、查看内存使用率1、top命令2、free命令(1).命令格式:(2).命令功能:(3) .命令参数:(4).使用实例:三、查看磁盘使用率1、输入df命令 一、查看CPU使用率 ...
  • 查看linux cpu和内存利用率

    万次阅读 2016-08-30 23:46:25
    在系统维护的过程中,随时可能有需要查看 CPU 使用率,并根据相应信息分析系统状况的需要。在 CentOS 中,可以通过 top 命令来查看 CPU 使用状况。运行 top 命令后,CPU 使用状态会以全屏的方式显示,并且会处在对话...
  • 1:CPU使用率 可参考linux系统查看CPU使用率的命令 常用命令:top top命令是Linux下常用的性能分析工具,能够实时显示系统中各个进程的资源占用状况,类似于Windows的任务管理器。 [root@izwz94b8tt3jlf3ne0ymp3z ~]...
  • 1770116 used 使用的物理内存总量 272500 free 空闲内存总量 163912 buffers 用作内核缓存的内存量 第五行(Swap): 表示类别同第四行(Mem),但此处反映着交换分区(Swap)的使用情况。通常,交换分区(Swap)被...
  • 因此,成熟稳健的系统往往需要对集群运行时的各个指标进行收集,如系统的load、CPU利用率、I/O繁忙程度、网络traffic、内存利用率、应用心跳等,对这些信息进行实时监控,如发现异常情况,能够第一时间通知到相应的...
  • Pytorch GPU内存占用很高,但是利用率很低

    万次阅读 多人点赞 2020-09-22 10:10:57
    输入nvidia-smi来观察显卡的GPU内存占用率(Memory-Usage),显卡的GPU利用率(GPU-util) GPU内存占用率(Memory-Usage) 往往是由于模型的大小以及batch size的大小,来影响这个指标 显卡的GPU利用率(GPU-util) ...
  • 1、获取cpu占用情况 [root@localhost utx86]# top -n 1 |grep Cpu Cpu(s): 1.9%us, 1.3%sy, 0.0%ni, 95.9%id, 0.6%wa, 0.1%hi, 0.2%si, 0.0%st 解释:1.9%us是用户占用cpu情况 ...2、获得内存占用情况 [root@
  • Linux查看CPU使用率内存使用率

    千次阅读 2020-04-16 11:56:01
    一、CPU使用率查看 1.cat /proc/loadavg命令 $ cat /proc/loadavg 0.08 0.06 0.10 1/442 8347 前三项分别是最近1分钟、5分钟和15分钟的系统平均负载。系统平均负载为在特定时间间隔内运行队列中的平均进程数,...
  • Linux查询CPU、磁盘、内存、IO使用率

    千次阅读 2021-12-22 10:33:37
    一、查看CPU使用率 1. top 命令 [root@sss ~]# top top - 16:54:38 up 7 days, 5:13, 3 users, load average: 0.00, 0.01, 0.05 Tasks: 77 total, 2 running, 75 sleeping, 0 stopped, 0 zombie %Cpu(s): 0.7 us, ...
  • android手机内存使用情况分析

    千次阅读 2017-09-08 15:47:21
     通常客户经常纠结手机内存使用率不合理,占有的内存太大,可用内存很少,客户往往需要给出解决方案或在给出原因,那么你首先需要知道手机的内存都被什么应用占有了,只有知道这个你才能找到解决方案或在给出客户...
  • Linux系统查看内存使用情况

    万次阅读 2021-10-13 16:16:38
    常用命令 查看内存使用情况:free 显示进程信息(包括CPU、内存使用等信息):top、ps 查看驱动占用内存:lsmod
  • python 获取内存和cpu的使用率

    千次阅读 2021-07-29 14:27:20
    获取远端设备的内存使用率和CPU使用率 Python前辈封装了一个Paramiko模块,允许我们通过SSH对远程系统进行操作,上传和下载文件非常方便。他的使用很直观,下面是使用Paramiko封装的一个获取cpu、内存使用率的一个...
  • Linux系统查看CPU使用率内存使用率、磁盘使用率

    万次阅读 多人点赞 2019-04-16 15:17:00
    一、查看CPU使用率 1. top 命令 top命令可以看到总体的系统运行状态和cpu的使用率 。 %us:表示用户空间程序的cpu使用率(没有通过nice调度) %sy:表示系统空间的cpu使用率,主要是内核程序。 %ni:表示用户空间...
  • 内存使用量减少高达90%的方法 使用棒球比赛日志 数据帧的内部表示 了解子类型 使用子类型优化数值列 将Numeric与String存储进行比较 使用分类优化对象类型 读取数据时选择类型 分析棒球比赛 总结和后续...
  • 类似于前面的技巧有关找出由RAM和CPU使用率最高的进程,还可以使用top命令来查看相同的信息。也许有相比前一个这种方法的一个额外的优势:顶级的“头”,提供有关当前状态和使用该系统的额外信息:正常运行时间,...
  • Linux下查看CPU、内存占用

    千次阅读 2021-10-14 16:06:42
    Linux下查看CPU、内存占用率 我们经常需要查看 CPU和内存...top命令可以查看CPU、内存利用率,当然这些值都是平均利用率,以下是安装APACHE+PHP+MYSQL后的运行情况,示例抓图如下: 其中, PID - 进程标示号 USER
  • 3、查看cpu和内存使用率 4、查看硬盘大小 1、查看cpu的方法 cat /proc/cpuinfo 2、查看内存使用 free -m total:表示物理,内存总量 used:总计分配给缓存(包含Buffer和cache)使用的数量,但其中可能...
  • 平常的工作中,在衡量服务器的性能时,经常会涉及到...在上一篇文章中,我们介绍了一个重要的指标就是负载(Load),其中我们提到Linux的负载高,主要是由于CPU使用内存使用、IO消耗三部分构成。任意一项使用过多...
  • GPU利用率使用

    万次阅读 2019-02-28 14:52:28
    GPU利用率 广义的GPU利用是指对GPU利用率效率,包括GPU空间和时间上的利用效率。 狭义的GPU利用率是指GPU时间片上的利用率; GPU可用的物理资源有哪些? GPU可利用资源:SM (计算单元)MEM(存储) Encoder...
  •  分别表示了内存总量、当前使用量、空闲内存量、以及缓冲使用中的内存量;  第五行(Swap):  表示类别同第四行(Mem),但此处反映着交换分区(Swap)的使用情况。通常,交换分区(Swap)被频繁...
  • 在PC领域,一直以来内存都是计算机中重要的组成部件,在我们日常使用过程中,内存起到与CPU沟通,并保证程序的正常运行,可以说内存的“性能”对计算机的影响非常大。这也是近年来内存价格不断变化直接影响DIY攒机的...
  • 2. 每间隔10分钟收集所有物理服务器CPU、内存使用率、网络带宽流量  Python 版本说明 Python 是由 Guido van Rossum 开发的、可免费获得的、非常高级的解释型语言。其语法简单易懂,而其面向对

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 230,592
精华内容 92,236
关键字:

内存平均使用量

友情链接: DDS.rar