Linux中sysinfo的用法

sysinfo结构体

Linux中,可以用sysinfo来获取系统相关信息。

Linux中,sysinfo是用来获取系统相关信息的结构体。
函数声明和原型：

#include <sys/sysinfo.h>

int sysinfo(struct sysinfo *info);

在Linux中不同对版本结构体不一样

在Linux 2.3.16中，结构体的信息是（单位是字节）：

1. struct sysinfo {                      
2. long uptime;                
3. /* 启动到现在经过的时间 */                      
4. unsigned long loads[3];      
5. /* 1, 5, and 15 minute load averages */                      
6. unsigned long totalram;  /* 总的可用的内存大小 */    
7. unsigned long freeram;   /* 还未被使用的内存大小 */    
8. unsigned long sharedram; /* 共享的存储器的大小 */    
9. unsigned long bufferram; /* 缓冲区大小 */                      
10. unsigned long totalswap; /* 交换区大小 */                      
11. unsigned long freeswap;  /* 还可用的交换区大小 */    
12. unsigned short procs;    /* 当前进程数目 */    
13. char _f[22];         /* 64字节的补丁结构 */    

struct sysinfo {                  
long uptime;            
/* 启动到现在经过的时间 */                  
unsigned long loads[3];  
/* 1, 5, and 15 minute load averages */                  
unsigned long totalram;  /* 总的可用的内存大小 */
unsigned long freeram;   /* 还未被使用的内存大小 */
unsigned long sharedram; /* 共享的存储器的大小 */
unsigned long bufferram; /* 缓冲区大小 */                  
unsigned long totalswap; /* 交换区大小 */                  
unsigned long freeswap;  /* 还可用的交换区大小 */
unsigned short procs;    /* 当前进程数目 */
char _f[22];         /* 64字节的补丁结构 */

在Linux 2.3.23(i386), 2.3.48 (all architectures)中，结构体的信息是（单位是mem_unit字节）：

1. struct sysinfo {  
2.       long uptime;          /* 启动到现在经过的时间 */  
3.       unsigned long loads[3];    
4.       /* 1, 5, and 15 minute load averages */  
5.       unsigned long totalram;  /* 总的可用的内存大小 */  
6.       unsigned long freeram;   /* 还未被使用的内存大小 */  
7.       unsigned long sharedram; /* 共享的存储器的大小*/  
8.       unsigned long bufferram; /* 共享的存储器的大小 */  
9.       unsigned long totalswap; /* 交换区大小 */  
10.       unsigned long freeswap;  /* 还可用的交换区大小 */  
11.       unsigned short procs;    /* 当前进程数目 */  
12.       unsigned long totalhigh; /* 总的高内存大小 */  
13.       unsigned long freehigh;  /* 可用的高内存大小 */  
14.       unsigned int mem_unit;   /* 以字节为单位的内存大小 */  
15.       char _f[20-2*sizeof(long)-sizeof(int)];   
16.       /* libc5的补丁  
17. };  

成功返回0，错误返回-1

例子：

#include <stdio.h>
#include <sys/sysinfo.h>

int main(void)
{
 struct sysinfo info;
 int iRetVal = -1;/*用于获取函数的返回值，默认为-1*/

 iRetVal = sysinfo(&info);
 printf("return val         : %d\n",iRetVal);//打印函数返回值，成功为0，失败为-1  
 printf("uptime          : %ld\n",info.uptime);//打印从设备开启到现在的时间，单位为秒    
 printf("1 min load average : %lu\n",info.loads[0]);    
 printf("5 min load average : %lu\n",info.loads[1]);    
 printf("15 min load average: %lu\n",info.loads[2]);//平均负载    
 printf("totalram           : %lu\n",info.totalram);//总可用内存大小  
 printf("freeram            : %lu\n",info.freeram); //剩余内存   
 printf("procs              : %u\n",info.procs);    //进程数

 return 0;
}

结果

return val     : 0
uptime         : 7595
1 min load ave : 7424
5 min laod ave : 17024
15 min load ave: 20032
totalarm       : 1713119232
freeram        : 1489481728
procs          : 148

补充知识：load average

average load?表示系统在一段时间内的平均进程个数，也就是表示系统的繁忙程度。average load和CPU利用率不一样，更加能够表示系统的繁忙程度，下面将就系统的average load的计算和相关进行简单介绍。

查看方法

在Linux系统下使用uptime命令，或者查看/proc/loadavg都可以看到系统负载average load。使用uptime命令会显示系统分别在过去的1分钟，5分钟和10分钟里的平均负载。

[root@localhost ~]# uptime
19:32:09 up 5 days, 8:53, 5 users, load average: 0.05, 0.04, 0.05
[root@localhost ~]# cat /proc/loadavg
0.04 0.04 0.05 1/394 23203

那么uptime命令计算load average的工作原理是什么呢？

计算方法

对于单cpu和多cpu情况，系统的average load情况稍有不同。单cpu是最简单的情形，比如过去的平均一分钟里面，判断系统处于运行或者等待状态的进程数则表示系统的平均负载，但是在linux系统下稍有不同，那些处于io等待状态的进程也会被纳入去计算。这样就导致CPU利用率可能和平均负载很不同，在大部分进程都在做IO的时候，即使平均负载很大，也会没有很大的CPU利用率。另外，有些系统对于进程和线程的处理也很不一样，有的对于每一个线程都会进行计算，有的只关注进程，对于超线程技术的线程来说，可能又是别的处理方式。对于多CPU的平均负载的计算，是在单CPU的情况下再除以CPU的个数。

文件: kernel/timer.c:

unsigned long avenrun[3];

static inline void calc_load(unsigned long ticks)
{
unsigned long active_tasks; /* fixed-point */
static int count = LOAD_FREQ;

count -= ticks;
if (count < 0) {
count += LOAD_FREQ;
active_tasks = count_active_tasks();
CALC_LOAD(avenrun[0], EXP_1, active_tasks);
CALC_LOAD(avenrun[1], EXP_5, active_tasks);
CALC_LOAD(avenrun[2], EXP_15, active_tasks);
}
}

内核中的函数sched.h

/*
 * These are the constant used to fake the fixed-point load-average
 * counting. Some notes:
 *  - 11 bit fractions expand to 22 bits by the multiplies: this gives
 *    a load-average precision of 10 bits integer + 11 bits fractional
 *  - if you want to count load-averages more often, you need more
 *    precision, or rounding will get you. With 2-second counting freq,
 *    the EXP_n values would be 1981, 2034 and 2043 if still using only
 *    11 bit fractions.
 */
extern unsigned long avenrun[];         /* Load averages */
extern void get_avenrun(unsigned long *loads, unsigned long offset, int shift);

#define FSHIFT          11              /* nr of bits of precision */
#define FIXED_1         (1<<FSHIFT)     /* 1.0 as fixed-point */
#define LOAD_FREQ       (5*HZ+1)        /* 5 sec intervals */
#define EXP_1           1884            /* 1/exp(5sec/1min) as fixed-point */
#define EXP_5           2014            /* 1/exp(5sec/5min) */
#define EXP_15          2037            /* 1/exp(5sec/15min) */

#define CALC_LOAD(load,exp,n) \
        load *= exp; \
        load += n*(FIXED_1-exp); \
        load >>= FSHIFT;

extern unsigned long total_forks;
extern int nr_threads;
DECLARE_PER_CPU(unsigned long, process_counts);
extern int nr_processes(void);
extern unsigned long nr_running(void);
extern unsigned long nr_uninterruptible(void);
extern unsigned long nr_iowait(void);
extern unsigned long nr_iowait_cpu(int cpu);
extern unsigned long this_cpu_load(void);

ewma算法

linux系统在很多方面都使用了这个算法，比如除了这个还有TC系统的CBQ算法，这是统计学的一个算法，具体请参考http://en.wikipedia.org/wiki/EWMA_chart和http://en.wikipedia.org/wiki/Moving_average

参考文献

http://man.he.net/man8/tc-cbq-details
linux内核代码
http://en.wikipedia.org/wiki/EWMA_chart
http://en.wikipedia.org/wiki/Moving_average 

struct sysinfo {
      long uptime;          /* 启动到现在经过的时间 */
      unsigned long loads[3];  
      /* 1, 5, and 15 minute load averages */
      unsigned long totalram;  /* 总的可用的内存大小 */
      unsigned long freeram;   /* 还未被使用的内存大小 */
      unsigned long sharedram; /* 共享的存储器的大小*/
      unsigned long bufferram; /* 共享的存储器的大小 */
      unsigned long totalswap; /* 交换区大小 */
      unsigned long freeswap;  /* 还可用的交换区大小 */
      unsigned short procs;    /* 当前进程数目 */
      unsigned long totalhigh; /* 总的高内存大小 */
      unsigned long freehigh;  /* 可用的高内存大小 */
      unsigned int mem_unit;   /* 以字节为单位的内存大小 */
      char _f[20-2*sizeof(long)-sizeof(int)]; 
      /* libc5的补丁
};