• Hadoop-Yarn-NodeManager如何计算Linux系统上的资源信息

    一、上下文

    中讲节点资源监控服务（NodeResourceMonitorImpl）时只是提了下SysInfoLinux，下面我们展开讲下

    SysInfoLinux是用于计算Linux系统上的资源信息的插件

    二、SysInfoLinux源码

    1. package org.apache.hadoop.util;
    2.  
    3. import java.io.BufferedReader;
    4. import java.io.FileInputStream;
    5. import java.io.FileNotFoundException;
    6. import java.io.InputStreamReader;
    7. import java.io.IOException;
    8. import java.math.BigInteger;
    9. import java.nio.charset.Charset;
    10. import java.util.HashMap;
    11. import java.util.HashSet;
    12. import java.util.regex.Matcher;
    13. import java.util.regex.Pattern;
    14. import com.google.common.annotations.VisibleForTesting;
    15. import org.apache.hadoop.classification.InterfaceAudience;
    16. import org.apache.hadoop.classification.InterfaceStability;
    17. import org.apache.hadoop.util.Shell.ShellCommandExecutor;
    18. import org.slf4j.Logger;
    19. import org.slf4j.LoggerFactory;
    20.  
    21. /**
    22.  * 用于计算Linux系统上的资源信息的插件
    23.  */
    24. @InterfaceAudience.Private
    25. @InterfaceStability.Evolving
    26. public class SysInfoLinux extends SysInfo {
    27.   private static final Logger LOG =
    28.       LoggerFactory.getLogger(SysInfoLinux.class);
    29.  
    30.   /**
    31.    * proc的meminfo虚拟文件具有以下格式的键值
    32.    * "key:[ \t]*value[ \t]kB".
    33.    */
    34.   private static final String PROCFS_MEMFILE = "/proc/meminfo";
    35.   private static final Pattern PROCFS_MEMFILE_FORMAT =
    36.       Pattern.compile("^([a-zA-Z_()]*):[ \t]*([0-9]*)[ \t]*(kB)?");
    37.  
    38.   //我们需要meminfo中以下键的值
    39.   private static final String MEMTOTAL_STRING = "MemTotal";
    40.   private static final String SWAPTOTAL_STRING = "SwapTotal";
    41.   private static final String MEMFREE_STRING = "MemFree";
    42.   private static final String SWAPFREE_STRING = "SwapFree";
    43.   private static final String INACTIVE_STRING = "Inactive";
    44.   private static final String INACTIVEFILE_STRING = "Inactive(file)";
    45.   private static final String HARDWARECORRUPTED_STRING = "HardwareCorrupted";
    46.   private static final String HUGEPAGESTOTAL_STRING = "HugePages_Total";
    47.   private static final String HUGEPAGESIZE_STRING = "Hugepagesize";
    48.  
    49.  
    50.  
    51.   /**
    52.    * 解析/proc/cpuinfo的样板
    53.    */
    54.   private static final String PROCFS_CPUINFO = "/proc/cpuinfo";
    55.   private static final Pattern PROCESSOR_FORMAT =
    56.       Pattern.compile("^processor[ \t]:[ \t]*([0-9]*)");
    57.   private static final Pattern FREQUENCY_FORMAT =
    58.       Pattern.compile("^cpu MHz[ \t]*:[ \t]*([0-9.]*)");
    59.   private static final Pattern PHYSICAL_ID_FORMAT =
    60.       Pattern.compile("^physical id[ \t]*:[ \t]*([0-9]*)");
    61.   private static final Pattern CORE_ID_FORMAT =
    62.       Pattern.compile("^core id[ \t]*:[ \t]*([0-9]*)");
    63.  
    64.   /**
    65.    * 解析/proc/stat的样板
    66.    */
    67.   private static final String PROCFS_STAT = "/proc/stat";
    68.   private static final Pattern CPU_TIME_FORMAT =
    69.       Pattern.compile("^cpu[ \t]*([0-9]*)" +
    70.                       "[ \t]*([0-9]*)[ \t]*([0-9]*)[ \t].*");
    71.   private CpuTimeTracker cpuTimeTracker;
    72.  
    73.   /**
    74.    * 解析/proc/net/dev的样板
    75.    */
    76.   private static final String PROCFS_NETFILE = "/proc/net/dev";
    77.   private static final Pattern PROCFS_NETFILE_FORMAT =
    78.       Pattern .compile("^[ \t]*([a-zA-Z]+[0-9]*):" +
    79.                "[ \t]*([0-9]+)[ \t]*([0-9]+)[ \t]*([0-9]+)[ \t]*([0-9]+)" +
    80.                "[ \t]*([0-9]+)[ \t]*([0-9]+)[ \t]*([0-9]+)[ \t]*([0-9]+)" +
    81.                "[ \t]*([0-9]+)[ \t]*([0-9]+)[ \t]*([0-9]+)[ \t]*([0-9]+)" +
    82.                "[ \t]*([0-9]+)[ \t]*([0-9]+)[ \t]*([0-9]+)[ \t]*([0-9]+).*");
    83.  
    84.   /**
    85.    * 解析/proc/diskstats的样板
    86.    */
    87.   private static final String PROCFS_DISKSFILE = "/proc/diskstats";
    88.   private static final Pattern PROCFS_DISKSFILE_FORMAT =
    89.       Pattern.compile("^[ \t]*([0-9]+)[ \t]*([0-9 ]+)" +
    90.               "(?!([a-zA-Z]+[0-9]+))([a-zA-Z]+)" +
    91.               "[ \t]*([0-9]+)[ \t]*([0-9]+)[ \t]*([0-9]+)[ \t]*([0-9]+)" +
    92.               "[ \t]*([0-9]+)[ \t]*([0-9]+)[ \t]*([0-9]+)[ \t]*([0-9]+)" +
    93.               "[ \t]*([0-9]+)[ \t]*([0-9]+)[ \t]*([0-9]+)");
    94.   /**
    95.    * 解析/sys/block/partition_name/queue/hw_sector_size的样板
    96.    */
    97.   private static final Pattern PROCFS_DISKSECTORFILE_FORMAT =
    98.       Pattern.compile("^([0-9]+)");
    99.  
    100.   private String procfsMemFile;
    101.   private String procfsCpuFile;
    102.   private String procfsStatFile;
    103.   private String procfsNetFile;
    104.   private String procfsDisksFile;
    105.   private long jiffyLengthInMillis;
    106.  
    107.   private long ramSize = 0;
    108.   private long swapSize = 0;
    109.   private long ramSizeFree = 0;  // 机器上的可用 ram 磁盘空间 (kB)
    110.   private long swapSizeFree = 0; // 机器上的可用 swap 空间 (kB)
    111.   private long inactiveSize = 0; // 不活跃内存 (kB)
    112.   private long inactiveFileSize = -1; // 非活动缓存，-1（如果不存在）
    113.   private long hardwareCorruptSize = 0; // RAM已损坏且不可用大小
    114.   private long hugePagesTotal = 0; // # 保留的标准大页
    115.   private long hugePageSize = 0; // # 每个标准大页的大小
    116.  
    117.  
    118.   /* 系统上的逻辑处理器数量. */
    119.   private int numProcessors = 0;
    120.   /* 系统上的物理核心数. */
    121.   private int numCores = 0;
    122.   private long cpuFrequency = 0L; // 系统上的CPU频率 (kHz)
    123.   private long numNetBytesRead = 0L; // 从网络读取的聚合字节
    124.   private long numNetBytesWritten = 0L; // 写入网络的聚合字节数
    125.   private long numDisksBytesRead = 0L; // 从磁盘读取的聚合字节数
    126.   private long numDisksBytesWritten = 0L; // 写入磁盘的聚合字节数
    127.  
    128.   private boolean readMemInfoFile = false;
    129.   private boolean readCpuInfoFile = false;
    130.  
    131.   /* 为每个磁盘映射其扇区大小 */
    132.   private HashMap perDiskSectorSize = null;
    133.  
    134.   public static final long PAGE_SIZE = getConf("PAGESIZE");
    135.   public static final long JIFFY_LENGTH_IN_MILLIS =
    136.       Math.max(Math.round(1000D / getConf("CLK_TCK")), -1);
    137.  
    138.   private static long getConf(String attr) {
    139.     if(Shell.LINUX) {
    140.       try {
    141.         ShellCommandExecutor shellExecutorClk = new ShellCommandExecutor(
    142.             new String[] {"getconf", attr });
    143.         shellExecutorClk.execute();
    144.         return Long.parseLong(shellExecutorClk.getOutput().replace("\n", ""));
    145.       } catch (IOException|NumberFormatException e) {
    146.         return -1;
    147.       }
    148.     }
    149.     return -1;
    150.   }
    151.  
    152.   /**
    153.    * 获取当前时间
    154.    * @return Unix时间戳（毫秒）
    155.    */
    156.   long getCurrentTime() {
    157.     return System.currentTimeMillis();
    158.   }
    159.  
    160.   public SysInfoLinux() {
    161.     this(PROCFS_MEMFILE, PROCFS_CPUINFO, PROCFS_STAT,
    162.          PROCFS_NETFILE, PROCFS_DISKSFILE, JIFFY_LENGTH_IN_MILLIS);
    163.   }
    164.  
    165.   /**
    166.    * 构造函数，它允许分配/proc/目录。这将仅用于单元测试
    167.    * @param procfsMemFile fake file for /proc/meminfo
    168.    * @param procfsCpuFile fake file for /proc/cpuinfo
    169.    * @param procfsStatFile fake file for /proc/stat
    170.    * @param procfsNetFile fake file for /proc/net/dev
    171.    * @param procfsDisksFile fake file for /proc/diskstats
    172.    * @param jiffyLengthInMillis fake jiffy length value
    173.    */
    174.   @VisibleForTesting
    175.   public SysInfoLinux(String procfsMemFile,
    176.                                        String procfsCpuFile,
    177.                                        String procfsStatFile,
    178.                                        String procfsNetFile,
    179.                                        String procfsDisksFile,
    180.                                        long jiffyLengthInMillis) {
    181.     this.procfsMemFile = procfsMemFile;
    182.     this.procfsCpuFile = procfsCpuFile;
    183.     this.procfsStatFile = procfsStatFile;
    184.     this.procfsNetFile = procfsNetFile;
    185.     this.procfsDisksFile = procfsDisksFile;
    186.     this.jiffyLengthInMillis = jiffyLengthInMillis;
    187.     this.cpuTimeTracker = new CpuTimeTracker(jiffyLengthInMillis);
    188.     this.perDiskSectorSize = new HashMap();
    189.   }
    190.  
    191.   /**
    192.    * 读 /proc/meminfo, 只解析和计算一次内存信息.
    193.    */
    194.   private void readProcMemInfoFile() {
    195.     readProcMemInfoFile(false);
    196.   }
    197.  
    198.   /**
    199.    *
    200.    * Long.parseLong（）的包装器，如果值无效则返回零。在某些情况下，
    201.    * /proc/meminfo中的swapFree可能为负数，报告为非常大的十进制值。
    202.    */
    203.   private long safeParseLong(String strVal) {
    204.     long parsedVal;
    205.     try {
    206.       parsedVal = Long.parseLong(strVal);
    207.     } catch (NumberFormatException nfe) {
    208.       parsedVal = 0;
    209.     }
    210.     return parsedVal;
    211.   }
    212.   /**
    213.    * 读 /proc/meminfo, 解析和计算内存信息.
    214.    * @param readAgain if false, read only on the first time
    215.    */
    216.   private void readProcMemInfoFile(boolean readAgain) {
    217.  
    218.     if (readMemInfoFile && !readAgain) {
    219.       return;
    220.     }
    221.  
    222.     // Read "/proc/memInfo" file
    223.     BufferedReader in;
    224.     InputStreamReader fReader;
    225.     try {
    226.       fReader = new InputStreamReader(
    227.           new FileInputStream(procfsMemFile), Charset.forName("UTF-8"));
    228.       in = new BufferedReader(fReader);
    229.     } catch (FileNotFoundException f) {
    230.       // shouldn't happen....
    231.       LOG.warn("Couldn't read " + procfsMemFile
    232.           + "; can't determine memory settings");
    233.       return;
    234.     }
    235.  
    236.     Matcher mat;
    237.  
    238.     try {
    239.       String str = in.readLine();
    240.       while (str != null) {
    241.         mat = PROCFS_MEMFILE_FORMAT.matcher(str);
    242.         if (mat.find()) {
    243.           if (mat.group(1).equals(MEMTOTAL_STRING)) {
    244.             ramSize = Long.parseLong(mat.group(2));
    245.           } else if (mat.group(1).equals(SWAPTOTAL_STRING)) {
    246.             swapSize = Long.parseLong(mat.group(2));
    247.           } else if (mat.group(1).equals(MEMFREE_STRING)) {
    248.             ramSizeFree = safeParseLong(mat.group(2));
    249.           } else if (mat.group(1).equals(SWAPFREE_STRING)) {
    250.             swapSizeFree = safeParseLong(mat.group(2));
    251.           } else if (mat.group(1).equals(INACTIVE_STRING)) {
    252.             inactiveSize = Long.parseLong(mat.group(2));
    253.           } else if (mat.group(1).equals(INACTIVEFILE_STRING)) {
    254.             inactiveFileSize = Long.parseLong(mat.group(2));
    255.           } else if (mat.group(1).equals(HARDWARECORRUPTED_STRING)) {
    256.             hardwareCorruptSize = Long.parseLong(mat.group(2));
    257.           } else if (mat.group(1).equals(HUGEPAGESTOTAL_STRING)) {
    258.             hugePagesTotal = Long.parseLong(mat.group(2));
    259.           } else if (mat.group(1).equals(HUGEPAGESIZE_STRING)) {
    260.             hugePageSize = Long.parseLong(mat.group(2));
    261.           }
    262.         }
    263.         str = in.readLine();
    264.       }
    265.     } catch (IOException io) {
    266.       LOG.warn("Error reading the stream " + io);
    267.     } finally {
    268.       //关闭流
    269.       try {
    270.         fReader.close();
    271.         try {
    272.           in.close();
    273.         } catch (IOException i) {
    274.           LOG.warn("Error closing the stream " + in);
    275.         }
    276.       } catch (IOException i) {
    277.         LOG.warn("Error closing the stream " + fReader);
    278.       }
    279.     }
    280.  
    281.     readMemInfoFile = true;
    282.   }
    283.  
    284.   /**
    285.    * 读 /proc/cpuinfo, 解析和计算CPU信息.
    286.    */
    287.   private void readProcCpuInfoFile() {
    288.     // 此目录只需读取一次
    289.     if (readCpuInfoFile) {
    290.       return;
    291.     }
    292.     HashSet coreIdSet = new HashSet<>();
    293.     // Read "/proc/cpuinfo" file
    294.     BufferedReader in;
    295.     InputStreamReader fReader;
    296.     try {
    297.       fReader = new InputStreamReader(
    298.           new FileInputStream(procfsCpuFile), Charset.forName("UTF-8"));
    299.       in = new BufferedReader(fReader);
    300.     } catch (FileNotFoundException f) {
    301.       // shouldn't happen....
    302.       LOG.warn("Couldn't read " + procfsCpuFile + "; can't determine cpu info");
    303.       return;
    304.     }
    305.     Matcher mat;
    306.     try {
    307.       numProcessors = 0;
    308.       numCores = 1;
    309.       String currentPhysicalId = "";
    310.       String str = in.readLine();
    311.       while (str != null) {
    312.         mat = PROCESSOR_FORMAT.matcher(str);
    313.         if (mat.find()) {
    314.           numProcessors++;
    315.         }
    316.         mat = FREQUENCY_FORMAT.matcher(str);
    317.         if (mat.find()) {
    318.           cpuFrequency = (long)(Double.parseDouble(mat.group(1)) * 1000); // kHz
    319.         }
    320.         mat = PHYSICAL_ID_FORMAT.matcher(str);
    321.         if (mat.find()) {
    322.           currentPhysicalId = str;
    323.         }
    324.         mat = CORE_ID_FORMAT.matcher(str);
    325.         if (mat.find()) {
    326.           coreIdSet.add(currentPhysicalId + " " + str);
    327.           numCores = coreIdSet.size();
    328.         }
    329.         str = in.readLine();
    330.       }
    331.     } catch (IOException io) {
    332.       LOG.warn("Error reading the stream " + io);
    333.     } finally {
    334.       // Close the streams
    335.       try {
    336.         fReader.close();
    337.         try {
    338.           in.close();
    339.         } catch (IOException i) {
    340.           LOG.warn("Error closing the stream " + in);
    341.         }
    342.       } catch (IOException i) {
    343.         LOG.warn("Error closing the stream " + fReader);
    344.       }
    345.     }
    346.     readCpuInfoFile = true;
    347.   }
    348.  
    349.   /**
    350.    * 读/proc/stat file, parse and calculate cumulative CPU.
    351.    */
    352.   private void readProcStatFile() {
    353.     // Read "/proc/stat" file
    354.     BufferedReader in;
    355.     InputStreamReader fReader;
    356.     try {
    357.       fReader = new InputStreamReader(
    358.           new FileInputStream(procfsStatFile), Charset.forName("UTF-8"));
    359.       in = new BufferedReader(fReader);
    360.     } catch (FileNotFoundException f) {
    361.       // shouldn't happen....
    362.       return;
    363.     }
    364.  
    365.     Matcher mat;
    366.     try {
    367.       String str = in.readLine();
    368.       while (str != null) {
    369.         mat = CPU_TIME_FORMAT.matcher(str);
    370.         if (mat.find()) {
    371.           long uTime = Long.parseLong(mat.group(1));
    372.           long nTime = Long.parseLong(mat.group(2));
    373.           long sTime = Long.parseLong(mat.group(3));
    374.           cpuTimeTracker.updateElapsedJiffies(
    375.               BigInteger.valueOf(uTime + nTime + sTime),
    376.               getCurrentTime());
    377.           break;
    378.         }
    379.         str = in.readLine();
    380.       }
    381.     } catch (IOException io) {
    382.       LOG.warn("Error reading the stream " + io);
    383.     } finally {
    384.       // Close the streams
    385.       try {
    386.         fReader.close();
    387.         try {
    388.           in.close();
    389.         } catch (IOException i) {
    390.           LOG.warn("Error closing the stream " + in);
    391.         }
    392.       } catch (IOException i) {
    393.         LOG.warn("Error closing the stream " + fReader);
    394.       }
    395.     }
    396.   }
    397.  
    398.   /**
    399.    * Read /proc/net/dev file, 解析并计算通过网络读取和写入的字节数。
    400.    */
    401.   private void readProcNetInfoFile() {
    402.  
    403.     numNetBytesRead = 0L;
    404.     numNetBytesWritten = 0L;
    405.  
    406.     // Read "/proc/net/dev" file
    407.     BufferedReader in;
    408.     InputStreamReader fReader;
    409.     try {
    410.       fReader = new InputStreamReader(
    411.           new FileInputStream(procfsNetFile), Charset.forName("UTF-8"));
    412.       in = new BufferedReader(fReader);
    413.     } catch (FileNotFoundException f) {
    414.       return;
    415.     }
    416.  
    417.     Matcher mat;
    418.     try {
    419.       String str = in.readLine();
    420.       while (str != null) {
    421.         mat = PROCFS_NETFILE_FORMAT.matcher(str);
    422.         if (mat.find()) {
    423.           assert mat.groupCount() >= 16;
    424.  
    425.           // 忽略环回接口
    426.           if (mat.group(1).equals("lo")) {
    427.             str = in.readLine();
    428.             continue;
    429.           }
    430.           numNetBytesRead += Long.parseLong(mat.group(2));
    431.           numNetBytesWritten += Long.parseLong(mat.group(10));
    432.         }
    433.         str = in.readLine();
    434.       }
    435.     } catch (IOException io) {
    436.       LOG.warn("Error reading the stream " + io);
    437.     } finally {
    438.       // Close the streams
    439.       try {
    440.         fReader.close();
    441.         try {
    442.           in.close();
    443.         } catch (IOException i) {
    444.           LOG.warn("Error closing the stream " + in);
    445.         }
    446.       } catch (IOException i) {
    447.         LOG.warn("Error closing the stream " + fReader);
    448.       }
    449.     }
    450.   }
    451.  
    452.   /**
    453.    * Read /proc/diskstats file, 解析和计算从磁盘读取和写入磁盘的字节数。
    454.    */
    455.   private void readProcDisksInfoFile() {
    456.  
    457.     numDisksBytesRead = 0L;
    458.     numDisksBytesWritten = 0L;
    459.  
    460.     // Read "/proc/diskstats" file
    461.     BufferedReader in;
    462.     try {
    463.       in = new BufferedReader(new InputStreamReader(
    464.             new FileInputStream(procfsDisksFile), Charset.forName("UTF-8")));
    465.     } catch (FileNotFoundException f) {
    466.       return;
    467.     }
    468.  
    469.     Matcher mat;
    470.     try {
    471.       String str = in.readLine();
    472.       while (str != null) {
    473.         mat = PROCFS_DISKSFILE_FORMAT.matcher(str);
    474.         if (mat.find()) {
    475.           String diskName = mat.group(4);
    476.           assert diskName != null;
    477.           // 忽略循环或ram分区
    478.           if (diskName.contains("loop") || diskName.contains("ram")) {
    479.             str = in.readLine();
    480.             continue;
    481.           }
    482.  
    483.           Integer sectorSize;
    484.           synchronized (perDiskSectorSize) {
    485.             sectorSize = perDiskSectorSize.get(diskName);
    486.             if (null == sectorSize) {
    487.               // 检索扇区大小
    488.               // 如果不可用或错误，假设512
    489.               sectorSize = readDiskBlockInformation(diskName, 512);
    490.               perDiskSectorSize.put(diskName, sectorSize);
    491.             }
    492.           }
    493.  
    494.           String sectorsRead = mat.group(7);
    495.           String sectorsWritten = mat.group(11);
    496.           if (null == sectorsRead || null == sectorsWritten) {
    497.             return;
    498.           }
    499.           numDisksBytesRead += Long.parseLong(sectorsRead) * sectorSize;
    500.           numDisksBytesWritten += Long.parseLong(sectorsWritten) * sectorSize;
    501.         }
    502.         str = in.readLine();
    503.       }
    504.     } catch (IOException e) {
    505.       LOG.warn("Error reading the stream " + procfsDisksFile, e);
    506.     } finally {
    507.       // Close the streams
    508.       try {
    509.         in.close();
    510.       } catch (IOException e) {
    511.         LOG.warn("Error closing the stream " + procfsDisksFile, e);
    512.       }
    513.     }
    514.   }
    515.  
    516.   /**
    517.    * Read /sys/block/diskName/queue/hw_sector_size file, 解析并计算特定磁盘的扇区大小
    518.    * @return sector size of specified disk, or defSector
    519.    */
    520.   int readDiskBlockInformation(String diskName, int defSector) {
    521.  
    522.     assert perDiskSectorSize != null && diskName != null;
    523.  
    524.     String procfsDiskSectorFile =
    525.             "/sys/block/" + diskName + "/queue/hw_sector_size";
    526.  
    527.     BufferedReader in;
    528.     try {
    529.       in = new BufferedReader(new InputStreamReader(
    530.             new FileInputStream(procfsDiskSectorFile),
    531.               Charset.forName("UTF-8")));
    532.     } catch (FileNotFoundException f) {
    533.       return defSector;
    534.     }
    535.  
    536.     Matcher mat;
    537.     try {
    538.       String str = in.readLine();
    539.       while (str != null) {
    540.         mat = PROCFS_DISKSECTORFILE_FORMAT.matcher(str);
    541.         if (mat.find()) {
    542.           String secSize = mat.group(1);
    543.           if (secSize != null) {
    544.             return Integer.parseInt(secSize);
    545.           }
    546.         }
    547.         str = in.readLine();
    548.       }
    549.       return defSector;
    550.     } catch (IOException|NumberFormatException e) {
    551.       LOG.warn("Error reading the stream " + procfsDiskSectorFile, e);
    552.       return defSector;
    553.     } finally {
    554.       // Close the streams
    555.       try {
    556.         in.close();
    557.       } catch (IOException e) {
    558.         LOG.warn("Error closing the stream " + procfsDiskSectorFile, e);
    559.       }
    560.     }
    561.   }
    562.  
    563.   /** {@inheritDoc} */
    564.   @Override
    565.   public long getPhysicalMemorySize() {
    566.     readProcMemInfoFile();
    567.     return (ramSize
    568.             - hardwareCorruptSize
    569.             - (hugePagesTotal * hugePageSize)) * 1024;
    570.   }
    571.  
    572.   /** {@inheritDoc} */
    573.   @Override
    574.   public long getVirtualMemorySize() {
    575.     return getPhysicalMemorySize() + (swapSize * 1024);
    576.   }
    577.  
    578.   /** {@inheritDoc} */
    579.   @Override
    580.   public long getAvailablePhysicalMemorySize() {
    581.     readProcMemInfoFile(true);
    582.     long inactive = inactiveFileSize != -1
    583.         ? inactiveFileSize
    584.         : inactiveSize;
    585.     return (ramSizeFree + inactive) * 1024;
    586.   }
    587.  
    588.   /** {@inheritDoc} */
    589.   @Override
    590.   public long getAvailableVirtualMemorySize() {
    591.     return getAvailablePhysicalMemorySize() + (swapSizeFree * 1024);
    592.   }
    593.  
    594.   /** {@inheritDoc} */
    595.   @Override
    596.   public int getNumProcessors() {
    597.     readProcCpuInfoFile();
    598.     return numProcessors;
    599.   }
    600.  
    601.   /** {@inheritDoc} */
    602.   @Override
    603.   public int getNumCores() {
    604.     readProcCpuInfoFile();
    605.     return numCores;
    606.   }
    607.  
    608.   /** {@inheritDoc} */
    609.   @Override
    610.   public long getCpuFrequency() {
    611.     readProcCpuInfoFile();
    612.     return cpuFrequency;
    613.   }
    614.  
    615.   /** {@inheritDoc} */
    616.   @Override
    617.   public long getCumulativeCpuTime() {
    618.     readProcStatFile();
    619.     return cpuTimeTracker.getCumulativeCpuTime();
    620.   }
    621.  
    622.   /** {@inheritDoc} */
    623.   @Override
    624.   public float getCpuUsagePercentage() {
    625.     readProcStatFile();
    626.     float overallCpuUsage = cpuTimeTracker.getCpuTrackerUsagePercent();
    627.     if (overallCpuUsage != CpuTimeTracker.UNAVAILABLE) {
    628.       overallCpuUsage = overallCpuUsage / getNumProcessors();
    629.     }
    630.     return overallCpuUsage;
    631.   }
    632.  
    633.   /** {@inheritDoc} */
    634.   @Override
    635.   public float getNumVCoresUsed() {
    636.     readProcStatFile();
    637.     float overallVCoresUsage = cpuTimeTracker.getCpuTrackerUsagePercent();
    638.     if (overallVCoresUsage != CpuTimeTracker.UNAVAILABLE) {
    639.       overallVCoresUsage = overallVCoresUsage / 100F;
    640.     }
    641.     return overallVCoresUsage;
    642.   }
    643.  
    644.   /** {@inheritDoc} */
    645.   @Override
    646.   public long getNetworkBytesRead() {
    647.     readProcNetInfoFile();
    648.     return numNetBytesRead;
    649.   }
    650.  
    651.   /** {@inheritDoc} */
    652.   @Override
    653.   public long getNetworkBytesWritten() {
    654.     readProcNetInfoFile();
    655.     return numNetBytesWritten;
    656.   }
    657.  
    658.   @Override
    659.   public long getStorageBytesRead() {
    660.     readProcDisksInfoFile();
    661.     return numDisksBytesRead;
    662.   }
    663.  
    664.   @Override
    665.   public long getStorageBytesWritten() {
    666.     readProcDisksInfoFile();
    667.     return numDisksBytesWritten;
    668.   }
    669.  
    670.   /**
    671.    * 测试 {@link SysInfoLinux}.
    672.    *
    673.    * @param args - arguments to this calculator test
    674.    */
    675.   public static void main(String[] args) {
    676.     SysInfoLinux plugin = new SysInfoLinux();
    677.     System.out.println("Physical memory Size (bytes) : "
    678.         + plugin.getPhysicalMemorySize());
    679.     System.out.println("Total Virtual memory Size (bytes) : "
    680.         + plugin.getVirtualMemorySize());
    681.     System.out.println("Available Physical memory Size (bytes) : "
    682.         + plugin.getAvailablePhysicalMemorySize());
    683.     System.out.println("Total Available Virtual memory Size (bytes) : "
    684.         + plugin.getAvailableVirtualMemorySize());
    685.     System.out.println("Number of Processors : " + plugin.getNumProcessors());
    686.     System.out.println("CPU frequency (kHz) : " + plugin.getCpuFrequency());
    687.     System.out.println("Cumulative CPU time (ms) : " +
    688.             plugin.getCumulativeCpuTime());
    689.     System.out.println("Total network read (bytes) : "
    690.             + plugin.getNetworkBytesRead());
    691.     System.out.println("Total network written (bytes) : "
    692.             + plugin.getNetworkBytesWritten());
    693.     System.out.println("Total storage read (bytes) : "
    694.             + plugin.getStorageBytesRead());
    695.     System.out.println("Total storage written (bytes) : "
    696.             + plugin.getStorageBytesWritten());
    697.     try {
    698.       // 睡眠，以便计算CPU使用量
    699.       Thread.sleep(500L);
    700.     } catch (InterruptedException e) {
    701.       // do nothing
    702.     }
    703.     System.out.println("CPU usage % : " + plugin.getCpuUsagePercentage());
    704.   }
    705.  
    706.   @VisibleForTesting
    707.   void setReadCpuInfoFile(boolean readCpuInfoFileValue) {
    708.     this.readCpuInfoFile = readCpuInfoFileValue;
    709.   }
    710.  
    711.   public long getJiffyLengthInMillis() {
    712.     return this.jiffyLengthInMillis;
    713.   }
    714. }

    从源码中可以看到，linux上的资源信息是从各个文件中获取的：

    /proc/meminfo    解析和计算内存信息
    /proc/cpuinfo    解析和计算CPU信息
    /proc/stat        获取CPU的运行数据
    /proc/net/dev    解析并计算通过网络读取和写入的字节数。
    /proc/diskstats    解析和计算从磁盘读取和写入磁盘的字节数
    /sys/block/partition_name/queue/hw_sector_size 解析并计算特定磁盘的扇区大小

    下面我们看下linux操作系统中的这些文件中都是什么内容

    三、proc下各示例文件

    1、/proc/meminfo

    MemTotal:       131479404 kB 
    MemFree:        29109144 kB
    MemAvailable:   109564132 kB
    Buffers:         3922940 kB
    Cached:         65545372 kB
    SwapCached:            0 kB
    Active:          9252304 kB
    Inactive:       79107168 kB
    Active(anon):     120256 kB
    Inactive(anon): 18893260 kB
    Active(file):    9132048 kB
    Inactive(file): 60213908 kB
    Unevictable:           0 kB
    Mlocked:               0 kB
    SwapTotal:             0 kB
    SwapFree:              0 kB
    Dirty:            123956 kB
    Writeback:             0 kB
    AnonPages:      18856940 kB
    Mapped:           151268 kB
    Shmem:            122260 kB
    KReclaimable:   12166144 kB
    Slab:           13454424 kB
    SReclaimable:   12166144 kB
    SUnreclaim:      1288280 kB
    KernelStack:       29584 kB
    PageTables:        88028 kB
    NFS_Unstable:          0 kB
    Bounce:                0 kB
    WritebackTmp:          0 kB
    CommitLimit:    65739700 kB
    Committed_AS:   34508552 kB
    VmallocTotal:   34359738367 kB
    VmallocUsed:      168540 kB
    VmallocChunk:          0 kB
    Percpu:           210432 kB
    HardwareCorrupted:     0 kB
    AnonHugePages:  12728320 kB
    ShmemHugePages:        0 kB
    ShmemPmdMapped:        0 kB
    FileHugePages:         0 kB
    FilePmdMapped:         0 kB
    DupText:               0 kB
    HugePages_Total:       0
    HugePages_Free:        0
    HugePages_Rsvd:        0
    HugePages_Surp:        0
    Hugepagesize:       2048 kB
    Hugetlb:               0 kB
    DirectMap4k:     2277228 kB
    DirectMap2M:    119357440 kB
    DirectMap1G:    14680064 kB

    /proc/meminfo是了解Linux系统内存使用状况的主要接口，我们最常用的”free”、”vmstat”等命令就是通过它获取数据的

    MemTotal：系统从加电开始到引导完成，firmware/BIOS要保留一些内存，kernel本身要占用一些内存，最后剩下可供kernel支配的内存就是MemTotal。这个值在系统运行期间一般是固定不变的

    MemFree：表示系统尚未使用的内存。[MemTotal-MemFree]就是已被用掉的内存

    MemAvailable：有些应用程序会根据系统的可用内存大小自动调整内存申请的多少，所以需要一个记录当前可用内存数量的统计值，MemFree并不适用，因为MemFree不能代表全部可用的内存，系统中有些内存虽然已被使用但是可以回收的，比如cache/buffer、slab都有一部分可以回收，所以这部分可回收的内存加上MemFree才是系统可用的内存，即MemAvailable。/proc/meminfo中的MemAvailable是内核使用特定的算法估算出来的，要注意这是一个估计值，并不精确

    Buffers：用于缓存数据的内存量

    Cached：用于缓存文件系统数据的内存量

    SwapCached：用于缓存交换分区数据的内存量

    Active：活跃内存量，活跃指最近被访问过或正在使用中的内存

    Inactive：非活跃内存量，非活跃指长时间没有被访问或已经释放但仍在缓冲区中的内存

    Active(anon)：活跃的匿名内存

    Inactive(anon)：不活跃的匿名内存

    Active(file)：活跃的文件使用内存

    Inactive(file)：不活跃的文件使用内存

    Unevictable：不能被释放的内存页

    Mlocked：系统调用 mlock 家族允许程序在物理内存上锁住它的部分或全部地址空间。这将阻止Linux 将这个内存页调度到交换空间（swap space），即使该程序已有一段时间没有访问这段空间

    SwapTotal：交换分区总容量

    SwapFree：交换分区剩余容量

    Dirty：脏页面数量，脏页面是指已经被修改但还没有被写回磁盘的页面

    Writeback：等待写回磁盘的页面数量

    AnonPages：未映射页的内存大小

    Mapped：设备和文件等映射的大小

    Shmem：包含共享内存以及tmpfs文件系统占用的内存

    KReclaimable：在SReclaimable的基础上加上MISC_RECLAIMABLE

    Slab：Slab是Linux中用来管理小块内核对象分配和释放的一种内存管理机制，Slab = SReclaimable + SUnreclaim

    SReclaimable：slab中可回收的部分

    SUnreclaim：slab中不可回收的部分

    KernelStack：内核消耗的内存

    PageTables：管理内存分页的索引表的大小

    NFS_Unstable：不稳定页表的大小

    Bounce：在低端内存中分配一个临时buffer作为跳转，把位于高端内存的缓存数据复制到此处消耗的内存

    WritebackTmp：FUSE用于临时写回缓冲区的内存

    CommitLimit：系统实际可分配内存

    Committed_AS：系统当前已分配的内存

    VmallocTotal：预留的虚拟内存总量

    VmallocUsed：已经被使用的虚拟内存

    VmallocChunk：可分配的最大的逻辑连续的虚拟内存

    Percpu：表示用于percpu分配的的内存大小，不包括metadata

    HardwareCorrupted：当系统检测到内存的硬件故障时删除掉的内存页的总量

    AnonHugePages：匿名大页缓存

    ShmemHugePages：表示用于shared memory或tmpfs的透明大页

    ShmemPmdMapped：表示用于用户态shared memory映射的透明大页

    FileHugePages：

    FilePmdMapped：

    DupText：

    HugePages_Total：预留的大页内存总量

    HugePages_Free：空闲的大页内存

    HugePages_Rsvd：已经被应用程序分配但尚未使用的大页内存

    HugePages_Surp：初始大页数与修改配置后大页数的差值

    Hugepagesize：单个大页内存的大小

    Hugetlb：

    DirectMap4k：映射TLB为4kB的内存数量

    DirectMap2M：映射TLB为2M的内存数量

    DirectMap1G：映射TLB为1G的内存数量

    2、/proc/cpuinfo

    processor       : 0
    vendor_id       : GenuineIntel
    cpu family      : 6
    model           : 85
    model name      : Intel Xeon Processor (Skylake, IBRS)
    stepping        : 4
    microcode       : 0x1
    cpu MHz         : 2299.992
    cache size      : 16384 KB
    physical id     : 0
    siblings        : 12
    core id         : 0
    cpu cores       : 12
    apicid          : 0
    initial apicid  : 0
    fpu             : yes
    fpu_exception   : yes
    cpuid level     : 13
    wp              : yes
    flags           : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ss ht syscall nx pdpe1gb rdtscp lm constant_tsc rep_good nopl xtopology c
    puid tsc_known_freq pni pclmulqdq ssse3 fma cx16 pcid sse4_1 sse4_2 x2apic movbe popcnt tsc_deadline_timer aes xsave avx f16c rdrand hypervisor lahf_lm abm 3dnowprefetch cpuid_fault invpcid
    _single ssbd ibrs ibpb stibp fsgsbase tsc_adjust bmi1 hle avx2 smep bmi2 erms invpcid rtm mpx avx512f avx512dq rdseed adx smap clflushopt clwb avx512cd avx512bw avx512vl xsaveopt xsavec xge
    tbv1 xsaves arat umip pku ospke md_clear
    bugs            : cpu_meltdown spectre_v1 spectre_v2 spec_store_bypass l1tf mds swapgs taa itlb_multihit mmio_stale_data retbleed
    bogomips        : 4599.98
    clflush size    : 64
    cache_alignment : 64
    address sizes   : 46 bits physical, 48 bits virtual
    power management:

    .................................省略...............................

    processor       : 23
    vendor_id       : GenuineIntel
    cpu family      : 6
    model           : 85
    model name      : Intel Xeon Processor (Skylake, IBRS)
    stepping        : 4
    microcode       : 0x1
    cpu MHz         : 2299.992
    cache size      : 16384 KB
    physical id     : 1
    siblings        : 12
    core id         : 11
    cpu cores       : 12
    apicid          : 27
    initial apicid  : 27
    fpu             : yes
    fpu_exception   : yes
    cpuid level     : 13
    wp              : yes
    flags           : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ss ht syscall nx pdpe1gb rdtscp lm constant_tsc rep_good nopl xtopology cpuid tsc_known_freq pni pclmulqdq ssse3 fma cx16 pcid sse4_1 sse4_2 x2apic movbe popcnt tsc_deadline_timer aes xsave avx f16c rdrand hypervisor lahf_lm abm 3dnowprefetch cpuid_fault invpcid_single ssbd ibrs ibpb stibp fsgsbase tsc_adjust bmi1 hle avx2 smep bmi2 erms invpcid rtm mpx avx512f avx512dq rdseed adx smap clflushopt clwb avx512cd avx512bw avx512vl xsaveopt xsavec xgetbv1 xsaves arat umip pku ospke md_clear
    bugs            : cpu_meltdown spectre_v1 spectre_v2 spec_store_bypass l1tf mds swapgs taa itlb_multihit mmio_stale_data retbleed
    bogomips        : 4599.98
    clflush size    : 64
    cache_alignment : 64
    address sizes   : 46 bits physical, 48 bits virtual
    power management:

    通过/proc/cpuinfo，可以查看系统中CPU的提供商和相关配置信息，例如我们想获取，有多少颗物理CPU，每个物理cpu核心数，以及超线程是否开启等信息，下面是每项参数的解释：

    processor ：系统中逻辑处理核心数的编号，从0开始排序

    vendor_id ：CPU制造商

    cpu family ：CPU产品系列代号

    model ：CPU属于其系列中的哪一代的代号

    model name：CPU属于的名字及其编号、标称主频

    stepping  ：CPU属于制作更新版本

    cpu MHz  ：CPU的实际使用主频

    cache size ：CPU二级缓存大小

    physical id ：单个物理CPU的标号

    siblings ：单个物理CPU的逻辑CPU数。siblings=cpu cores [*2]

    core id ：当前物理核在其所处CPU中的编号，这个编号不一定连续

    cpu cores ：该逻辑核所处CPU的物理核数。比如此处cpu cores 是4个，那么对应core id 可能是 1、3、4、5。

    apicid ：用来区分不同逻辑核的编号，系统中每个逻辑核的此编号必然不同，此编号不一定连续

    fpu ：是否具有浮点运算单元（Floating Point Unit）

    fpu_exception ：是否支持浮点计算异常

    cpuid level ：执行cpuid指令前，eax寄存器中的值，根据不同的值cpuid指令会返回不同的内容

    wp ：表明当前CPU是否在内核态支持对用户空间的写保护（Write Protection）

    flags ：当前CPU支持的功能

    bugs ：保存内核检测到的硬件错误

    bogomips：在系统内核启动时粗略测算的CPU速度（Million Instructions Per Second

    clflush size ：每次刷新缓存的大小单位

    cache_alignment ：缓存地址对齐单位

    address sizes ：可访问地址空间位数

    power management ：对能源管理的支持

    3、/proc/stat

    cpu  8736131408 5678 193273561 20516569092 64420147 202089758 24839900 736849109 0 0
    cpu0 248135539 221 7727953 977102347 3547852 7843342 1836321 26959080 0 0
    cpu1 288960610 208 7253118 939752913 3465875 6253758 983012 22610655 0 0
    cpu2 331782665 173 6580943 898614791 3179773 5927649 705463 20377701 0 0
    cpu3 357312958 119 6079401 873515056 3082820 5636253 675032 19192651 0 0
    cpu4 416415379 134 4970987 817517624 2702326 5029001 461878 15707695 0 0
    cpu5 431656991 49 4560783 803250964 2571613 4865074 410522 14757252 0 0
    cpu6 435254195 169 4473639 799793313 2533305 4816086 391800 14568012 0 0
    cpu7 430149966 193 5306474 799970897 2274711 5119291 4203530 15644401 0 0
    cpu8 442943177 38 4245770 792483084 2429873 4720225 472371 14247201 0 0
    cpu9 450045462 66 4306296 784947171 2410185 4660788 1014418 13736325 0 0
    cpu10 451355787 39 4064980 784676208 2261500 4619102 396365 13709422 0 0
    cpu11 457452811 64 3901559 778822656 2231050 4565301 393815 13362096 0 0
    cpu12 308242715 360 10256742 887773491 2996516 16295533 1139546 52646450 0 0
    cpu13 291977604 326 12356349 906520116 2948164 14127718 995623 49241553 0 0
    cpu14 314799511 763 11789179 887439430 2724265 12548004 926359 45887607 0 0
    cpu15 343893959 589 10565703 861975365 2476760 11234089 879714 42636791 0 0
    cpu16 357686825 202 9889055 850148237 2299417 10596337 839523 40920853 0 0
    cpu17 371250803 336 9230196 838222800 2170862 10053101 814107 39442271 0 0
    cpu18 381559924 227 8684083 829076848 2133621 9640147 793837 38300080 0 0
    cpu19 391204359 360 8217143 820527206 2044874 9294489 780223 37347635 0 0
    cpu20 395787749 376 7934865 816504952 2030798 9101060 793620 36768582 0 0
    cpu21 382765684 287 8586382 826536768 2751789 9517617 1313220 39011440 0 0
    cpu22 403637541 284 7699240 808560612 3025058 8623423 868515 35789081 0 0
    cpu23 51859181 83 24592711 1132836231 4127127 17002359 2751076 73984264 0 0
    intr 41293626138 0 9 0 0 250 0 0 0 0 0 1257757 0 15 0 12281947 0 0 0 0 0 0 0 0 0 0 74418226 0 9915152 0 62205235 0 16892400 0 170973248 4915 0 3076909346 41960 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 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 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 66125412027
    btime 1695643289
    processes 68123558
    procs_running 20
    procs_blocked 0
    softirq 26896249797 0 1534546890 2296517 681491783 147607814 0 4570937 2751393260 9053148 290452968

    /proc/stat记录的是系统进程整体的统计信息

    cpu ~ cpu23 描述的指标如下：(单位都是jiffies，1jiffies=0.01秒)

    nameusernicesystemidleiowaitirrqsoftirqstealguestguest_nice
    cpu8736131408567819327356120516569092644201472020897582483990073684910900
    …………………………………………………………
    cpu23518591818324592711113283623141271271700235927510767398426400

    这部分统计了CPU时间消耗分布在哪些地方,是用户态任务,还是内核或者是中断、idle等等；第一行的第一个字段为"cpu"，没有指定CPU号，表示是其他各个CPU时间分布的汇总；而其他行有cpu编号表示特定编号的cpu时间消耗分布情况。

    name：cpu汇总/cpu编号

    user：到目前为止，CPU上nice值不大于0的用户态任务的运行时间

    nice：到目前为止，CPU上nice值大于0的用户态任务的运行时间

    system：到目前为止，CPU上内核态的运行时间。包括用户态任务系统调用、异常等陷入内核消耗时间，也包括内核线程消耗的时间； 但是不包括中断和软中断的执行时间

    idle：到目前为止，处于idle任务的时间。不包括CPU上因为任务IO阻塞导致CPU上没有任务可运行、处于idle状态的时间。

    iowait：到目前为止，由于CPU上任务IO阻塞导致CPU无可运行任务、处于idle的时间。需要强调的是，iowait是在CPU处于idle状态下的一种特殊情况的时间，与上面的“idle”列互补构成CPU上真正处于idle的时间。

    irrq：到目前为止，CPU进入到中断处理的时间(在没有使能CONFIG_IRQ_TIME_ACCOUNTING的情况下，大部分架构实际上无法记录到该项，见下面的分析)。

    softirq：到目前为止，CPU处理软中断的时间，包括softirqd中处理软中断的时间。

    steal：与虚拟化有关

    guest：与虚拟化有关

    guest_nice：与虚拟化有关

    其他指标如下：

    intr：系统启动以来的所有interrupts的次数情况

    ctxt: 系统上下文切换次数

    btime：启动时长(单位:秒)，从Epoch(即1970零时)开始到系统启动所经过的时长，每次启动会改变。此处指为1695643289，转换北京时间为2023-09-25 20:01:29

    processes：系统启动后所创建过的进程数量。当短时间该值特别大，系统可能出现异常

    procs_running：处于Runnable状态的进程个数

    procs_blocked：处于被阻塞的进程个数

    softirq：此行显示所有CPU的softirq总数，第一列是所有软件和每个软件的总数，后面的列是特定softirq的总数

    4、/proc/net/dev

    Inter-|   Receive                                                |  Transmit
     face |bytes    packets errs drop fifo frame compressed multicast|bytes    packets errs drop fifo colls carrier compressed
        lo: 8262570189990 1009625458    0 1217    0     0          0         0 8262570189990 1009625458    0    0    0     0       0          0
      eth0: 4725352845467 3727035213    0    0    0     0          0         0 12125473603784 322028286    0    0    0     0       0          0
      eth1: 12250497813726 9789277543    0 1066    0     0          0         0 12066904463831 2712923220    0    0    0     0       0          0

    /proc/net/dev提供了网络设备接口的统计信息，lo、eth0、eth1为网络社保接口的名称。下面是具体指标解释

    bytes：接收或发送的总字节数。

    packets：接收或发送的总数据包数量。

    errs：在接收或发送过程中发生的错误数量。

    drop：由于缓冲区溢出或其他原因而丢弃的数据包数量。

    fifo：由于队列拥塞而丢弃的数据包数量。

    frame：由于帧错误而丢弃的数据包数量。

    compressed：压缩传输所节省的字节数量。

    multicast：接收到多播数据包的数量。

    5、/proc/diskstats

     253       0 vda 978184 4128 81150594 20755299 73453182 4078455 1309816689 398292145 0 113223744 426791458 0 0 0 0 15585634 7744013 20200452 365556940 0
     253       1 vda1 977999 4128 81131978 20753990 72102739 4078455 1309816681 396863176 0 112567056 417617166 0 0 0 0 0 0 20199145 365556938 0
     253      16 vdb 10371383 566918 5197295816 186317736 4253043 5537854 2637106896 128050659 0 68754698 314653319 0 0 0 0 411815 284922 185895864 126318932 0
     253      17 vdb1 10371274 566918 5197280288 186316863 4253012 5537854 2637106896 128050617 0 68754916 314367481 0 0 0 0 0 0 185894994 126318932 0
     253      32 vdc 62355261 2902021 51036086962 4222776827 51209471 48829571 38641223240 1144000034 1 453445155 1073094954 0 0 0 0 1186448 1285388 4096018303 1082051035 0
      11       0 sr0 352 0 3115 420 0 0 0 0 0 456 420 0 0 0 0 0 0 419 0 0

    /proc/diskstatsv提供了磁盘信息的统计信息，含义从左到右依次如下

    设备号 编号 设备  读完成次数  合并完成次数   读扇区次数   读操作花费毫秒数   写完成次数   合并写完成次数   写扇区次数   写操作花费的毫秒数   正在处理的输入/输出请求数   输入/输出操作花费的毫秒数   输入/输出操作花费的加权毫秒数

    6、/sys/block/partition_name/queue/hw_sector_size

    通过hw_sector_size可以获取磁盘块大小相关的信息。我们把partition_name换成vda、vdb、vdc或者sr0即可，注意：下面的512就是文件的内容

    vda、vdb、vdc的磁盘块大小为

    512

    sr0的磁盘块大小为

    2048

  • 相关阅读:
    【TB作品】MSP430G2553，单片机，口袋板， 烘箱温度控制器
    微信小程序获取用户头像昵称组件封装（最新版）
    Vue-cli3 通过配置 public 目录下的 config.js 和config.json 实现一次编译，修改生效
    设计模式学习（三）：工厂模式
    网上选课系统的设计与实现（ASP.NET）
    react-navigation学习
    嵌入式面试常见问题（一）
    【Leetcode刷题Python】416. 分割等和子集
    GPU性能优化与模型训练概览
    Lua脚本
  • 原文地址：https://blog.csdn.net/lu070828/article/details/136146608