在Linux中如果要監視一個程序的執行情況，如檢視它的CPU使用效率和記憶體使用情況，就需要從系統的 /proc目錄的讀取一些系統資訊。然後分析得到結果，proc檔案系統是一個偽檔案系統，它只存在記憶體當中，而不佔用外存空間。它以檔案系統的方式為訪問系統核心資料的操作提供介面。使用者和應用程式 可以通過proc得到系統的資訊，並可以改變核心的某些引數。

1、從/proc檔案系統獲取相關的效能引數
cpu使用率：    /proc/stat
記憶體使用情況：      /proc/meminfo
網路負載資訊：    /proc/net/dev

相應的計算方法：(摘自：什麼是proc檔案系統，見參考資料)
（1）   處理器使用率   
（2）   記憶體使用率   
（3）   流入流出資料包   
（4）   整體網路負載   

這些資料分別要從/proc/stat、/proc/net/dev、/proc/meminfo三個檔案中提取。如裡有問題或對要提取的資料不太清楚， 可以使用man   proc來檢視proc檔案系統的聯機手冊。  

（1）   處理器使用率   
這裡要從/proc/stat中提取四個資料：使用者模式（user）、低優先順序的使用者模式（nice）、核心模式（system）以及空閒的處理器時間 （idle）。它們均位於/proc/stat檔案的第一行。CPU的使用率使用如下公式來計算。

在Linux系統中，CPU利用率的計算來源在/proc/stat檔案，這個檔案的頭幾行記錄了每個CPU的使用者態，系統態，空閒態等狀態下的不同的 Jiffies，常用的監控軟體就是利用/proc/stat裡面的這些資料來計算CPU的利用率的。/proc/stat/

[email protected]:~# cat /proc/stat
cpu  2262 0 4387 204441 3670 101 27 0 0
cpu0 2262 0 4387 204441 3670 101 27 0 0

  
CPU使用率 =  100   *（user   +   nice   +   system）/（user   +   nice   +   system   +   idle）

要計算使用者和系統的相對使用率要對/proc/stat資料進行兩次採集，再進行計算

total1 = user1 + nice1 + system1 + idle1 ，total2同理（total1採集時間比total2晚，所以total1> total2）

使用者使用率 = 100 * （user1 - user2）/ （total1 - total2）

系統使用率 = 100 * （system1 - system2）/ （total1 - total2）

（2）   記憶體使用率   

這裡需要從/proc/meminfo檔案中提取兩個資料，當前記憶體的未使用量(MemFree)以及記憶體總量(MemTotal)。   
記憶體使用百分比   =   100   *   ((MemTotal - MemFree)   /  MemTotal)   

[email protected]:~# cat /proc/meminfo
MemTotal:         509208 kB
MemFree:           93596 kB

（3）網路利用率   

為了得到網路利用率的相關資料，需要從/proc/net/dev檔案中獲得兩個資料：從本機輸出的資料包數，流入本機的資料包數。它們都位於這個檔案的 第四行。效能收集程式開始記錄下這兩個資料的初始值，以後每次獲得這個值後均減去這個初始值即為從叢集啟動開始從本節點通過的資料包。利用上述資料計算出網路的丟包率，方法如下：   
丟包率   =   (第二次採集總丟包數 - 第一次採集總丟包數)   /   採集時間

Inter-|   Receive                                                |  Transmit
 face |bytes    packets errs drop fifo frame compressed multicast|bytes    packets errs drop fifo colls carrier compressed
    lo:   10732     132    0    0    0     0          0         0    10732     132    0    0    0     0       0          0
  eth0:   33096     179    0    0    0     0          0         0    15743     146    0    0    0     0       0          0

下面是我寫的程式碼，其中用到了定時器30S進行一次資訊採集，最開始獲取cpu對於total使用率，而不是使用者和系統相對的使用率

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

#include <time.h>
#include <signal.h>
#include <pthread.h>

static int g_cpu_used_user = 0;		//表示cpu使用者使用率
static int g_cpu_used_system = 0;	//表示cpu系統使用率
static unsigned long cpu_total = 0;	
static unsigned long cpu_user = 0;
static unsigned long cpu_system = 0;//分別cpu總時間，使用者時間，系統時間
static unsigned int mem_free;		//存放未使用記憶體
static unsigned int mem_used;		//存放已使用記憶體
static unsigned int R_bytes = 0;
static unsigned int R_packets = 0;
static short int R_drop = 0;
static unsigned int T_bytes = 0;
static unsigned int T_packets = 0;
static short T_drop = 0;
static short int R_drop_per = 0;	//網路接收丟包率
static short int T_drop_per = 0;	//網路接收丟包率 

struct occupy						//存放cpu資料結構體
{
	char name[20];
	unsigned int user;
	unsigned int nice;
	unsigned int system;
	unsigned int idle;
};

struct mem_occupy					//存放記憶體資料結構體
{
	char name_total[20];
	unsigned int total;
	char name_free[20];
	unsigned int free;
};

struct net_occupy					//存放網口資料結構體
{
	char name[20];
	unsigned int R_bytes;
	unsigned int R_packets;
	unsigned int R_errs;
	unsigned int R_drop;
	unsigned int fifo;
	unsigned int frame;
	unsigned int compressed;
	unsigned int multicast;
	unsigned int T_bytes;
	unsigned int T_packets;
	unsigned int T_errs;
	unsigned int T_drop;
};

int cal_occupy(struct occupy *ncpu);
void get_occupy(struct occupy *ocpu);
int get_cpu_info(void);
int get_mem_info(struct mem_occupy *mem);
int get_net_info(void);
static void get_opera_data(void);
void settimer_get_opera_data(void);


/*******獲取cpu資料，存入靜態全域性變數
g_cpu_used_eser和g_cpu_used_system中*/
int get_cpu_info()
{
	struct occupy cpu;
	get_occupy(&cpu);		//獲取資料存入結構體
	cal_occupy(&cpu);		//根據資料計算cpu使用率
	
	printf("cpu_num = 1 user used:%d system used:%d\n",
			 g_cpu_used_user, g_cpu_used_system);
}

int cal_occupy(struct occupy *ncpu)
{
	unsigned long od,nd;
	unsigned long id,sd;
	od = cpu_total;
	nd = (unsigned long)(ncpu->user + ncpu->nice + ncpu->system + ncpu->idle);
	id = (unsigned long)(ncpu->user - cpu_user);
	sd = (unsigned long)(ncpu->system - cpu_system);
	if ((nd - od) != 0) {
		g_cpu_used_user = (int)(id * 100)/(nd - od);
		g_cpu_used_system = (int)(sd * 100)/(nd - od);
	} else {
		g_cpu_used_user = 0;
		g_cpu_used_system = 0;
	}
	
	//將計算獲得資料儲存
	cpu_total = nd;
	cpu_user = ncpu->user;
	cpu_system = ncpu->system;
	return (1);
}

/*從/proc/stat檔案中提取cpu資料狀態*/
void get_occupy(struct occupy *ocpu)
{
	FILE *fd;
	char buff[256];
	struct occupy *ncpu;
	ncpu = ocpu;

	fd = fopen("/proc/stat", "r");
	if (!fd) {
		perror("cannot open /proc/stat");
		exit(EXIT_FAILURE);
	}

	while(fgets(buff, sizeof(buff), fd)) {
		if(strstr(buff, "cpu") != NULL) {
			sscanf(buff,"%s %u %u %u %u", ncpu->name, &(ncpu->user),
					&(ncpu->nice), &(ncpu->system), &(ncpu->idle));
			break;
		} 
	}
	printf("%u %u %u %u",ncpu->user,ncpu->nice,ncpu->system,ncpu->idle); 	
	fclose(fd);
}

/*從 /proc/meminfo 檔案中提取記憶體資料*/
int get_mem_info(struct mem_occupy *mem)
{
	FILE *fd;
	char buff[256];

	fd = fopen("/proc/meminfo", "r");
	if (!fd) {
		perror("Cannot open /proc/meminfo");
		return(0);
	}
	fgets(buff, sizeof(buff), fd);
	if (strstr(buff, "MemTotal") != NULL) {
		sscanf(buff, "%s %u", mem->name_total, &mem->total);
	} else return(0);
	fgets(buff, sizeof(buff), fd);
	if (strstr(buff, "MemFree") != NULL) {
		sscanf(buff, "%s %u", mem->name_free, &mem->free);
	} else return(0);
	mem_free = mem->free;
	mem_used = mem->total - mem->free;

	printf("mem_free = %u ,mem_used = %u",mem_free,mem_used);
	return (1);
}

/*提取網口資料，計算丟包率*/
int get_net_info()
{
	FILE *fd;
	int i, n = 0;
	char buff[256];
	unsigned int R_bytes_new = 0;
	unsigned int R_packets_new = 0;
	unsigned int R_drop_new = 0;
	unsigned int T_bytes_new = 0;
	unsigned int T_packets_new = 0;
	unsigned int T_drop_new = 0;
	struct net_occupy netinfo[4];

	fd = fopen("/proc/net/dev", "r+");
	if (!fd) {
		perror("Cannot open /proc/net/dev");
		return(0);
	}
	while(fgets(buff, sizeof(buff), fd)) {
		n++;
		if(n > 3) {
			sscanf(buff,"%s %u %u %u %u %u %u %u %u %u %u %u %u",
				netinfo[n-4].name, &netinfo[n-4].R_bytes, &netinfo[n-4].R_packets, 
				&netinfo[n-4].R_errs, &netinfo[n-4].R_drop, &netinfo[n-4].fifo,
				&netinfo[n-4].frame, &netinfo[n-4].compressed, &netinfo[n-4].multicast,
				&netinfo[n-4].T_bytes, &netinfo[n-4].T_packets, &netinfo[n-4].T_errs,
				&netinfo[n-4].T_drop);
		}
	}

	for(i = 0; i < n - 4; i++) {
		R_bytes_new += netinfo[i].R_bytes;
		R_packets_new += netinfo[i].R_packets;
		R_drop_new += netinfo[i].R_drop;
		T_bytes_new += netinfo[i].T_bytes;
		T_packets_new += netinfo[i].T_packets;
		T_drop_new += netinfo[i].T_drop;
	}
	if (0 == (R_packets_new - R_packets)) {
		R_drop_per = 0;
	}
	else 
		R_drop_per = (unsigned short int)((R_drop_new - R_drop)* 100.0 / 
									(R_packets_new - R_packets));
	if (0 == (T_packets_new - T_packets)) {
		T_drop_per = 0;
	}
	else 
		T_drop_per = (unsigned short int)((T_drop_new - T_drop)* 100.0 / 
									(T_packets_new - T_packets));

	printf("R_drop = %u T_drop = %u\n",R_drop_per,T_drop_per);
	R_bytes = R_bytes_new;
	R_drop = R_drop_new;
	R_packets = R_packets_new;
	T_bytes = T_bytes_new;
	T_drop = T_drop_new;
	T_packets = T_packets_new;
	return(1);
}

static void get_opera_data(void)
{	
	struct mem_occupy mem;
	get_cpu_info();
	get_mem_info(&mem);
	get_net_info();
} 

void settimer_get_opera_data(void)
{
	struct sigevent se;
	struct itimerspec ts, ots;
	timer_t tid;

	memset(&se, 0, sizeof(se));
	se.sigev_notify = SIGEV_THREAD;
	se.sigev_notify_function = get_opera_data;//定時執行函式，獲取運維資料
	se.sigev_value.sival_int = 0;
	if (timer_create(CLOCK_REALTIME, &se, &tid) < 0) {
		perror("timer_creat of operation and maintenance\n");
	}
	ts.it_value.tv_sec = 28;
	ts.it_value.tv_nsec = 0;
	ts.it_interval = ts.it_value;
	if (timer_settime(tid, 0, &ts, &ots) < 0) {
		perror("time_settime of operation and maintenance\n");
	}
}

int main()
{
	get_opera_data();
	settimer_get_opera_data();
	while(1);
	return(1);
}