【cpu_loading】/proc/stat统计cpu的使用率

其他 2018-06-03 06:06:52 阅读次数: 1

参考：http://www.blogjava.net/fjzag/articles/317773.html

基于目前正在开发的手机

proc伪文件系统

/proc文件系统是一个伪文件系统，它只存在内存当中，而不占用外存空间。它以文件系统的方式为内核与进程提供通信的接口。用户和应用程序可以通过/proc得到系统的信息，并可以改变内核的某些参数。由于系统的信息，如进程，是动态改变的，所以用户或应用程序读取/proc目录中的文件时，proc文件系统是动态从系统内核读出所需信息并提交的。

/proc目录中有一些以数字命名的目录，它们是进程目录。系统中当前运行的每一个进程在/proc下都对应一个以进程号为目录名的目录/proc/pid，它们是读取进程信息的接口。此外，在Linux 2.6.0-test6以上的版本中/proc/pid目录中有一个task目录，/proc/pid/task目录中也有一些以该进程所拥有的线程的线程号命名的目录/proc/pid/task/tid，它们是读取线程信息的接口。

proc/stat

该文件中的所有值都是系统启动至今的数据，不同内核版本时间单位可能不同

cat stat
cpu  69904 21104 138494 23477594 1232 0 317 0 0 0
cpu0 28792 2066 56307 2858036 131 0 125 0 0 0
cpu1 27146 1804 51688 2860147 84 0 15 0 0 0
cpu2 5561 1066 10786 2943586 87 0 105 0 0 0
cpu3 4716 642 7122 2951398 35 0 6 0 0 0
cpu4 2109 9525 8942 2952628 626 0 40 0 0 0
cpu5 916 2241 2465 2968654 145 0 10 0 0 0
cpu6 361 1950 682 2971229 62 0 8 0 0 0
cpu7 300 1808 501 2971912 60 0 6 0 0 0
intr 10805705 0 3500279 5996187 0 0 1 18 54 973 26755 0 0 115777 0 5 31482 0 0 0 0 77498 0 22550 28 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 4610 0 0 0 0 0 0 0 0 0 0 0 0 27384 0 0 2965 2947 0 17 1 0 0 1 0 1 27
 0 0 0 6 10 249 0 0 0 0 0 0 0
ctxt 7732037
btime 1325375998
processes 28877
procs_running 1
procs_blocked 0
softirq 5725677 1 2134789 0 0 0 0 74120 1979642 0 1537125

cpu  69904 21104 138494 23477594 1232 0 317 0 0 0

是CPU总的使用情况：

进程的nice，进程的nice值一般是-20～19，他影响的是cpu分配给进程的时间片

对nice值一个形象比喻，假设在一个CPU轮转中，有2个runnable的进程A和B，如果他们的nice值都为0，假设内核会给他们每人分配1k个cpu时间片。但是假设进程A的为0，但是B的值为-10，那么此时CPU可能分别给A和B分配1k和1.5k的时间片。故可以形象的理解为，nice的值影响了内核分配给进程的cpu时间片的多少，时间片越多的进程，其优先级越高

参数：                            解析

(jiffies是内核中的一个全局变量，用来记录自系统启动一来产生的节拍数，在linux中，一个节拍大致可理解为操作系统进程调度的最小时间片，不同linux内核可能值有不同，通常在1ms到10ms之间)类似time_in_stat里面的时间取的是10ms

user：69904                                处于用户态的运行时间，不包含nice值为负的进程

nice：21104                                nice值为负的进程所占用的CPU时间

system：138494                        核心态（内核态）的运行时间

idle：23477594                           除I/O等待时间以外的其他等待时间

iowait：1232                                IO等待时间（since 2.5.41之后加入）

irq：0                                              硬中断时间

softirq:317                                       软中断的时间

stealstolen：0                                which is the time spent in other operating systems when running in a virtualized environment(since 2.6.11)

guest:0                                              which is the time spent running a virtual  CPU  for  guest operating systems under the control of the Linux kernel(since 2.6.24)

   至于这个结论，我不是很赞同啊

总的cpu时间totalCpuTime = user + nice + system + idle + iowait + irq + softirq + stealstolen  +  guest

下面是根据上面的内容计算出的cpu的使用率

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <sys/time.h>

#include "cpu_loading.h"

static si get_argv(char *time_char)
{
	char *ch = time_char;
	si ret = 0;
	
	if( *ch == '0'){
		fprintf(stderr, "interval should not be zero\n");
		return INVALID_ARGV;
	}

	for(ch=time_char; *ch; ch++){
		if( *ch == '-' || !(*ch >= '0' || *ch <= '9')){
			fprintf(stderr, "please input the correct argv time(no negative)\n");
			return INVALID_ARGV;
		}
		ret = ret*10+(*ch-'0');
	}
	return ret;
}

static s8 get_init_freq_count(const char *cpu_cur_path, u8 *size, ui *cpu_available_freq)
{
	FILE	*fp = NULL;
	fp = fopen(cpu_cur_path, "r");
	u8 i = 0;
	if(fp==NULL){
		fprintf(stderr, "failed opend file:", cpu_cur_path);
		return INVALID_ARGV;
	}
	// even freq   
	// odd count
	for(i=0; i<MAX_AVALLABLE_FREQ; i=i+2){
		cpu_available_freq[i+1] = 0;
		if(fscanf(fp,"%d", cpu_available_freq+i)!=1)
			break;
	}
	*size = i;
	fclose(fp);
	return 0;
}

static void debug_cpufreq_count(u8 cpu0_size,  ui *cpu0_available_freq, 
u8 cpu4_size, ui *cpu4_available_freq)
{
	u8 i = 0;
	for(i=0;i<cpu0_size; i=i+2){
		printf("%d\t%d\n", cpu0_available_freq[i], cpu0_available_freq[i+1]);
	}
	printf("\n");
	
	for(i=0;i<cpu4_size; i=i+2){
		printf("%d\t%d\n", cpu4_available_freq[i], cpu4_available_freq[i+1]);
	}
}


static s8 calculate_freq_percent(const u8 cpu_size,  ui *cpu_available_freq, ui total_count, char *file_path)
{
	u8 i = 0;
	FILE *fp = NULL;
	fp = fopen(file_path, "r");
	ui cur_cpu = 0;
	if(fp==NULL){
		fprintf(stderr, "", file_path);
		return FAILED_OPEN_FILE;
	}
	while(fscanf(fp,"%d", &cur_cpu)==1){
		for(i=0;i<cpu_size; i=i+2){
			if(cur_cpu==cpu_available_freq[i]){
				cpu_available_freq[i+1]++;
				break;
			}
			
		}
	}
	
	fclose(fp);
	return 0;
}

static s8 statistic_cpu_stat(const char *stat_path, ui count)
{
	FILE *fp = NULL;
	FILE *fp_cpu = NULL;
	char cpu_stat[BUFFER_SIZE];
	char *result_stat;
	u8 i = 0;
	
	fp = fopen(stat_path, "r");
	if(fp==NULL){
		fprintf(stderr, "failed opend file:\n", stat_path);
		return INVALID_ARGV;
	}
	if(count%2==0){
		fp_cpu = fopen(START_STAT,"a");
	}else{
		fp_cpu = fopen(END_STAT,"a");
	}
	
	if(fp_cpu==NULL){
		fprintf(stderr, "failed opend file:\n");
		return INVALID_ARGV;
	}
	
	fgets(cpu_stat, BUFFER_SIZE, fp);
	while(fgets(cpu_stat, BUFFER_SIZE, fp)&&i<8){
		result_stat = cpu_stat+3;
		fprintf(fp_cpu, "%s", result_stat);
		i++;
	}
	fclose(fp);
	fclose(fp_cpu);
	return 0;
}

static s8 store_cpu_freq(ui cur_freq, char *file_path)
{
	FILE *fp = NULL;
	fp = fopen(file_path, "a");
	if(fp==NULL){
		fprintf(stderr, "failed opend file:\n", file_path);
		return FAILED_OPEN_FILE;
	}
	fprintf(fp, "%d\n", cur_freq);
	fclose(fp);
	return 0;
}

static ui get_store_cur_freq(const char *file_path, char *store_path)
{
	FILE	*fp = NULL;
	ui cur_cpu_freq = 0;
	fp = fopen(file_path, "r");
	if(fp==NULL){
		fprintf(stderr, "failed opend file:\n", file_path);
		return INVALID_ARGV;
	}
	fscanf(fp, "%d", &cur_cpu_freq);
	fclose(fp);
	store_cpu_freq(cur_cpu_freq, store_path);
	return 0;
}

static void clear_envirment()
{
	remove(LITTLE_CORE);
	remove(BIG_CORE);
	remove(START_STAT);
	remove(END_STAT);
}
static s8 data_simpling(si accummulate_time, si interval, ui total_count)
{	
	struct timeval start, end;
	float timeuse = 0.0;
	ui	 count = 0;
	u8 i = 0;
	gettimeofday(&start, NULL);
	while(count<total_count){
		get_store_cur_freq(CPU0_CUR_FREQ_PATH, LITTLE_CORE);
		get_store_cur_freq(CPU4_CUR_FREQ_PATH, BIG_CORE);
		statistic_cpu_stat(PROC_CPU_STAT, count);
		usleep(100000);
		count++;
	}
	gettimeofday(&end, NULL);
	timeuse = (1000000 * ( end.tv_sec - start.tv_sec ) + end.tv_usec - start.tv_usec)/1000.0;
	printf("time_use is %.2f\n", timeuse);
	
}

static s8 compute_cpu_loading(char *start_file, char *end_file, float *pcpu_set)
{
	FILE *fp_start, *fp_end;
	ui start_buffer[BUFFER_SIZE], end_buffer[BUFFER_SIZE];
	memset(start_buffer, 0, BUFFER_SIZE);
	memset(end_buffer, 0, BUFFER_SIZE);
	u8 i = 0, cpu_id, j;
	const u8 cpu_consist = 11;
	uli  total_time = 0;
	ui   idle_time = 0, set = 0;
	float pcpu = 0.0;
	
	fp_start = fopen(start_file, "r");
	if(fp_start==NULL){
		fprintf(stderr, "failed opend file", start_file);
		return FAILED_OPEN_FILE;
	}
	fp_end = fopen(end_file, "r");
	if(fp_end==NULL){
		fprintf(stderr, "failed opend file", end_file);
		return FAILED_OPEN_FILE;
	}
	
	while(fscanf(fp_start, "%d", start_buffer+i)==1 &&
	fscanf(fp_end, "%d", end_buffer+i)==1
	){
		if(i==0){
			cpu_id = start_buffer[i];
		}
		ui minus = end_buffer[i]-start_buffer[i];
		total_time+=minus;
		if(i==4){
			idle_time = minus;
			//printf("%d\t%d\t%d\t%d\n", end_buffer[i], start_buffer[i], idle_time, total_time);
		}
		i++;
		if(i==cpu_consist){
			set++;
			pcpu = ((total_time-idle_time)*1.0/total_time);
			//printf("%d\t%f\n", cpu_id, pcpu);
			pcpu_set[cpu_id]+=pcpu;
			i=0;
			total_time = 0;
			memset(start_buffer, 0, BUFFER_SIZE);
		}
	}
	set/=8;
	for(i=0;i<=cpu_id; i++){
		pcpu_set[i] /=set;
		printf("cpu%d is %f\n", i, pcpu_set[i]);
	}
	
	fclose(fp_start);
	fclose(fp_end);
	return 0;
}

int main(int argc, char *argv[])
{
	si   interval , accummulate_time = 0;
	ui   cpu0_freq , cpu4_freq = 0;
	ui	 total_count = 0;
	u8 	 cpu0_size, cpu4_size, i , j ;
	ui 	 cpu0_available_freq[MAX_AVALLABLE_FREQ], cpu4_available_freq[MAX_AVALLABLE_FREQ];
	float pcpu_set[BUFFER_SIZE];

	// input argc less than 1
	if( argc < 1 ){
		fprintf(stderr, "you must input two argv");
		fprintf(stderr, "first: cal cpu loading tool \n");
		fprintf(stderr, "secn: interval time(default:100ms) \n");
		fprintf(stderr, "expl: ./data/cpu_loading 100\n");
		return INVALID_ARGV;
	}
	
	// input argc 1
	if(argc==1){
		interval = 100;
		accummulate_time = 60;
		
	// input argc 2
	}else if(argc==2){
		interval = get_argv(argv[1]);
		if(interval<0){
			return INVALID_ARGV;
		}
		accummulate_time = 60;
	// input argc 3
	}else{
		interval = get_argv(argv[1]);
		if(interval<0){
			return INVALID_ARGV;
		}
		accummulate_time = get_argv(argv[2]);
		if(accummulate_time<0){
			return INVALID_ARGV;
		}
	}
	
	printf("interval is %d\n", interval);
	printf("accummulate_time is %d\n", accummulate_time);

	get_init_freq_count(CPU0_AVAILABLE_FREQ_PATH, &cpu0_size, cpu0_available_freq);
	get_init_freq_count(CPU4_AVAILABLE_FREQ_PATH, &cpu4_size, cpu4_available_freq);
	
	// debug
	//debug_cpufreq_count(cpu0_size, cpu0_available_freq ,cpu4_size, cpu4_available_freq);
	total_count = (accummulate_time*1000)/interval;
	clear_envirment();
	// data cimpling
	data_simpling(accummulate_time, interval, total_count);

	

	calculate_freq_percent(cpu0_size, cpu0_available_freq, total_count, LITTLE_CORE);
	calculate_freq_percent(cpu4_size, cpu4_available_freq, total_count, BIG_CORE);
	// debug
	debug_cpufreq_count(cpu0_size, cpu0_available_freq ,cpu4_size, cpu4_available_freq);
	
	// compute pcpux
	compute_cpu_loading(START_STAT, END_STAT, pcpu_set);
	
	// show result
	for(i=0; i<cpu0_size; i=i+2){
		if(i==0)
			printf("\t");
		printf("%d\t", cpu0_available_freq[i]);
		if(i==cpu0_size-2)
			printf("\n");
	}
	for(i=0; i<cpu0_size; i=i+2){
		if(i==0)
			printf("little\t");
		printf("%.3f%\t", cpu0_available_freq[i+1]*1.0/total_count*100);
		if(i==cpu0_size-2)
			printf("\n");
	}
	
	for(i=0;i<4;i++){
		printf("cpu%d\t", i);
		for(j=0;j<cpu0_size;j=j+2){
			printf("%.3f%\t", (cpu0_available_freq[j+1]*1.0/total_count)*100*pcpu_set[i]);
		}
		printf("\n");
	}
	
	printf("\n");
	for(i=0; i<cpu4_size; i=i+2){
		if(i==0)
			printf("\t");
		printf("%d\t", cpu4_available_freq[i]);
		if(i==cpu4_size-2)
			printf("\n");
	}
	for(i=0; i<cpu4_size; i=i+2){
		if(i==0)
			printf("big\t");
		printf("%.3f%\t", cpu4_available_freq[i+1]*1.0/total_count*100);
		if(i==cpu4_size-2)
			printf("\n");
	}
	for(i=4;i<8;i++){
		printf("cpu%d\t", i);
		for(j=0;j<cpu4_size;j=j+2){
			printf("%.3f%\t", (cpu4_available_freq[j+1]*1.0/total_count)*100*pcpu_set[i]);
		}
		printf("\n");
	}
	
	return 0;
}

其中头文件的定义如下：

#define INVALID_ARGV		-1
#define FAILED_OPEN_FILE	-2
#define MAX_AVALLABLE_FREQ	40
#define BUFFER_SIZE			512

#define CPU0_CUR_FREQ_PATH			"/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq"
#define CPU4_CUR_FREQ_PATH			"/sys/devices/system/cpu/cpu4/cpufreq/scaling_cur_freq"
#define CPU0_AVAILABLE_FREQ_PATH	"/sys/devices/system/cpu/cpu0/cpufreq/scaling_available_frequencies"
#define CPU4_AVAILABLE_FREQ_PATH	"/sys/devices/system/cpu/cpu4/cpufreq/scaling_available_frequencies"
#define PROC_CPU_STAT				"/proc/stat"
#define LITTLE_CORE					"/sdcard/little_core"
#define BIG_CORE					"/sdcard/big_core"
#define START_STAT					"/sdcard/stat_start.txt"
#define END_STAT					"/sdcard/stat_end.txt"

typedef signed 		int    si;
typedef signed		char   s8;
typedef unsigned    char   u8;
typedef unsigned	int    ui;
typedef unsigned long int  uli;

运行结果如下：


从另一个维度计算cpu_loading，简称

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <sys/time.h>

#include "cpu_loading.h"

static void debug_cpufreq_count(u8 cpu0_size,  ui *cpu0_available_freq, 
u8 cpu4_size, ui *cpu4_available_freq, ui total_count)
{
	u8 i = 0;
	for(i=0;i<cpu0_size; i=i+2){
		printf("%d\t%.2f%\n", cpu0_available_freq[i], cpu0_available_freq[i+1]*1.0/total_count*100);
	}
	printf("\n");
	
	for(i=0;i<cpu4_size; i=i+2){
		printf("%d\t%.2f%\n", cpu4_available_freq[i], cpu4_available_freq[i+1]*1.0/total_count*100);
	}
}


static si get_argv(char *time_char)
{
	char *ch = time_char;
	si ret = 0;
	
	if( *ch == '0'){
		fprintf(stderr, "interval should not be zero\n");
		return INVALID_ARGV;
	}

	for(ch=time_char; *ch; ch++){
		if( *ch == '-' || !(*ch >= '0' || *ch <= '9')){
			fprintf(stderr, "please input the correct argv time(no negative)\n");
			return INVALID_ARGV;
		}
		ret = ret*10+(*ch-'0');
	}
	return ret;
}

static s8 get_init_freq_count(const char *cpu_cur_path, u8 *size, ui *cpu_available_freq)
{
	FILE	*fp = NULL;
	fp = fopen(cpu_cur_path, "r");
	u8 i = 0;
	if(fp==NULL){
		fprintf(stderr, "failed opend file:", cpu_cur_path);
		return INVALID_ARGV;
	}
	// even freq   
	// odd count
	for(i=0; i<MAX_AVALLABLE_FREQ; i=i+2){
		cpu_available_freq[i+1] = 0;
		if(fscanf(fp,"%d", cpu_available_freq+i)!=1)
			break;
	}
	*size = i;
	fclose(fp);
	return 0;
}

static void clear_envirment()
{
	remove(LITTLE_CORE);
	remove(BIG_CORE);
	remove(START_STAT);
	remove(END_STAT);
	remove(PCPU_PATH);
}

static s8 statistic_cpu_stat(const char *stat_path, ui count)
{
	FILE *fp = NULL;
	FILE *fp_cpu = NULL;
	char cpu_stat[BUFFER_SIZE];
	char *result_stat;
	u8 i = 0;
	
	fp = fopen(stat_path, "r");
	if(fp==NULL){
		fprintf(stderr, "failed opend file:\n", stat_path);
		return INVALID_ARGV;
	}
	if(count%2==0){
		fp_cpu = fopen(START_STAT,"a");
	}else{
		fp_cpu = fopen(END_STAT,"a");
	}
	
	if(fp_cpu==NULL){
		fprintf(stderr, "failed opend file:\n");
		return INVALID_ARGV;
	}
	// aband sum pcpu 
	fgets(cpu_stat, BUFFER_SIZE, fp);
	
	while(fgets(cpu_stat, BUFFER_SIZE, fp)&&i<8){
		result_stat = cpu_stat+3;
		fprintf(fp_cpu, "%s", result_stat);
		i++;
	}
	fclose(fp);
	fclose(fp_cpu);
	return 0;
}

static s8 store_cpu_freq(ui cur_freq, char *file_path)
{
	FILE *fp = NULL;
	fp = fopen(file_path, "a");
	if(fp==NULL){
		fprintf(stderr, "failed opend file:\n", file_path);
		return FAILED_OPEN_FILE;
	}
	fprintf(fp, "%d\n", cur_freq);
	fclose(fp);
	return 0;
}

static ui get_store_cur_freq(const char *file_path, char *store_path)
{
	FILE	*fp = NULL;
	ui cur_cpu_freq = 0;
	fp = fopen(file_path, "r");
	if(fp==NULL){
		fprintf(stderr, "failed opend file:\n", file_path);
		return INVALID_ARGV;
	}
	fscanf(fp, "%d", &cur_cpu_freq);
	fclose(fp);
	store_cpu_freq(cur_cpu_freq, store_path);
	return 0;
}


static s8 data_simpling(si accummulate_time, si interval, ui total_count)
{	
	struct timeval start, end;
	float timeuse = 0.0;
	ui	 count = 0;
	u8 i = 0;
	gettimeofday(&start, NULL);
	while(count<total_count){
		get_store_cur_freq(CPU0_CUR_FREQ_PATH, LITTLE_CORE);
		get_store_cur_freq(CPU4_CUR_FREQ_PATH, BIG_CORE);
		statistic_cpu_stat(PROC_CPU_STAT, count);
		usleep(interval*1000);
		count++;
	}
	gettimeofday(&end, NULL);
	timeuse = (1000000 * ( end.tv_sec - start.tv_sec ) + end.tv_usec - start.tv_usec)/1000.0;
	printf("time_use is %.2f\n", timeuse);
	
}

static s8 store_pcpu(u8 cpu_id,  float pcpu)
{
	FILE *fp = NULL;
	fp = fopen(PCPU_PATH, "a");
	if(fp==NULL){
		fprintf(stderr, "failed opend file:\n", PCPU_PATH);
		return FAILED_OPEN_FILE;
	}
	fprintf(fp, "%f\n",  pcpu);
	fclose(fp);
	return 0;
}

static si compute_cpu_loading_freq(char *start_file, char *end_file, float *pcpu_set)
{
	FILE *fp_start, *fp_end;
	ui start_buffer[BUFFER_SIZE], end_buffer[BUFFER_SIZE];
	memset(start_buffer, 0, BUFFER_SIZE);
	memset(end_buffer, 0, BUFFER_SIZE);
	u8 i = 0, cpu_id, j;
	const u8 cpu_consist = 11;
	uli  total_time = 0;
	ui   idle_time = 0, set = 0;
	float pcpu = 0.0;
	
	fp_start = fopen(start_file, "r");
	if(fp_start==NULL){
		fprintf(stderr, "failed opend file", start_file);
		return FAILED_OPEN_FILE;
	}
	fp_end = fopen(end_file, "r");
	if(fp_end==NULL){
		fprintf(stderr, "failed opend file", end_file);
		return FAILED_OPEN_FILE;
	}
	
	while(fscanf(fp_start, "%d", start_buffer+i)==1 &&
	fscanf(fp_end, "%d", end_buffer+i)==1){
		if(i==0){
			cpu_id = start_buffer[i];
		}
		ui minus = end_buffer[i]-start_buffer[i];
		total_time+=minus;
		if(i==4){
			idle_time = minus;
			//printf("%d\t%d\t%d\t%d\n", end_buffer[i], start_buffer[i], idle_time, total_time);
		}
		i++;
		if(i==cpu_consist){
			set++;
			pcpu = ((total_time-idle_time)*1.0/total_time);
			store_pcpu(cpu_id, pcpu);
			pcpu_set[cpu_id]+=pcpu;
			i=0;
			total_time = 0;
			memset(start_buffer, 0, BUFFER_SIZE);
		}
	}
	set/=8;
	
	fclose(fp_start);
	fclose(fp_end);
	return set;
}

static s8 calculate_freq_percent(const u8 cpu0_size,  ui *cpu0_available_freq, 
ui total_count, const u8 cpu4_size,  ui *cpu4_available_freq, si set_group)
{
	u8 i = 0, k;
	ui j = 0;
	FILE *fp_cpu0 = NULL;
	FILE *fp_cpu4 = NULL;
	FILE *fp_stat = NULL;
	ui cpu0_cur_cpu, cpu4_cur_cpu;
	float pcpu[BUFFER_SIZE];
	float pcpu_per[MAX_AVALLABLE_FREQ][BUFFER_SIZE*10];
	ui   pcpu_per_count[MAX_AVALLABLE_FREQ][BUFFER_SIZE*10];
	fp_cpu0 = fopen(LITTLE_CORE, "r");
	if(fp_cpu0==NULL){
		fprintf(stderr, "", LITTLE_CORE);
		return FAILED_OPEN_FILE;
	}
	fp_cpu4 =fopen(BIG_CORE, "r");
	if(fp_cpu4==NULL){
		fprintf(stderr, "", BIG_CORE);
		return FAILED_OPEN_FILE;
	}
	fp_stat = fopen(PCPU_PATH, "r");
	if(fp_stat==NULL){
		fprintf(stderr, "", PCPU_PATH);
		return FAILED_OPEN_FILE;
	}
	while(fscanf(fp_cpu0,"%d", &cpu0_cur_cpu)==1&&
	fscanf(fp_cpu4,"%d", &cpu4_cur_cpu)==1){
		for(i=0;i<cpu0_size; i=i+2){
			if(cpu0_cur_cpu==cpu0_available_freq[i]){
				cpu0_available_freq[i+1]++;
				break;
			}
		}	
		for(i=0;i<cpu4_size; i=i+2){
			if(cpu4_cur_cpu==cpu4_available_freq[i]){
				cpu4_available_freq[i+1]++;
				break;
			}
		}
		
		if(j%2==1){
			i=0;
			while(fscanf(fp_stat, "%f", pcpu+i)==1){
				pcpu_per[i][cpu0_cur_cpu/1000]+=pcpu[i];
				pcpu_per_count[i][cpu0_cur_cpu/1000]++;
				//printf("%d\t%d\t%f\t%d\n", i, cpu0_cur_cpu, pcpu[i], pcpu_per_count[i][cpu0_cur_cpu/1000]);
				i++;
				if(i>3){
					break;
				}
			}
			while(fscanf(fp_stat, "%f", pcpu+i)==1){
				pcpu_per[i][cpu4_cur_cpu/1000]+=pcpu[i];
				pcpu_per_count[i][cpu4_cur_cpu/1000]++;
				//printf("%d\t%d\t%.2f\t%d\n", i, cpu4_cur_cpu, pcpu[i],pcpu_per_count[i][cpu4_cur_cpu/1000]);
				i++;
				if(i>7){
					break;
				}
			}
		}
		j++;
		
	}
	fclose(fp_cpu0);
	fclose(fp_stat);


	for(j=0;j<cpu0_size;j=j+2){
		if(j==0)
			printf("   \t");
		printf("%d\t", cpu0_available_freq[j]);
		if(j==cpu0_size-2)
			printf("\n");
	}

	for(i=0;i<4;i++){
		printf("%d\t", i);
		for(j=0;j<cpu0_size;j=j+2){
			if(pcpu_per_count[i][cpu0_available_freq[j]/1000]!=0){
				printf("%.2f%\t", pcpu_per[i][cpu0_available_freq[j]/1000]/(pcpu_per_count[i][cpu0_available_freq[j]/1000])*100);
			}else{
				printf("0.00%\t");
			}	
		}
		printf("\n");
	}
	printf("\n");
	for(j=0;j<cpu4_size;j=j+2){
		if(j==0)
			printf("   \t");
		printf("%d\t", cpu4_available_freq[j]);
		if(j==cpu4_size-2)
			printf("\n");
	}
	for(i=4;i<8;i++){
		printf("%d\t", i);
		for(j=0;j<cpu4_size;j=j+2){
			if(pcpu_per_count[i][cpu4_available_freq[j]/1000]!=0){
				printf("%.2f%\t", pcpu_per[i][cpu4_available_freq[j]/1000]/(pcpu_per_count[i][cpu4_available_freq[j]/1000])*100);
			}else{
				printf("0.00%\t");
			}	
		}
		printf("\n");
	}
	return 0;
}

int main(int argc, char *argv[])
{
	si   interval , accummulate_time = 0, set_group;
	ui   cpu0_freq , cpu4_freq = 0;
	ui	 total_count = 0;
	u8 	 cpu0_size, cpu4_size, i , j ;
	ui 	 cpu0_available_freq[MAX_AVALLABLE_FREQ], cpu4_available_freq[MAX_AVALLABLE_FREQ];
	float pcpu_set[BUFFER_SIZE];

	// input argc less than 1
	if( argc < 1 ){
		fprintf(stderr, "you must input two argv");
		fprintf(stderr, "first: cal cpu loading tool \n");
		fprintf(stderr, "secn: interval time(default:100ms) \n");
		fprintf(stderr, "expl: ./data/cpu_loading 100\n");
		return INVALID_ARGV;
	}
	
	// input argc 1
	if(argc==1){
		interval = 100;
		accummulate_time = 60;
		
	// input argc 2
	}else if(argc==2){
		interval = get_argv(argv[1]);
		if(interval<0){
			return INVALID_ARGV;
		}
		accummulate_time = 60;
	// input argc 3
	}else{
		interval = get_argv(argv[1]);
		if(interval<0){
			return INVALID_ARGV;
		}
		accummulate_time = get_argv(argv[2]);
		if(accummulate_time<0){
			return INVALID_ARGV;
		}
	}
	
	printf("interval is %d\n", interval);
	printf("accummulate_time is %d\n", accummulate_time);

	get_init_freq_count(CPU0_AVAILABLE_FREQ_PATH, &cpu0_size, cpu0_available_freq);
	get_init_freq_count(CPU4_AVAILABLE_FREQ_PATH, &cpu4_size, cpu4_available_freq);
	
	// debug
	//debug_cpufreq_count(cpu0_size, cpu0_available_freq ,cpu4_size, cpu4_available_freq);
	total_count = (accummulate_time*1000)/interval;
	clear_envirment();
	// data cimpling
	data_simpling(accummulate_time, interval, total_count);
	
	set_group = compute_cpu_loading_freq(START_STAT, END_STAT, pcpu_set);
	calculate_freq_percent(cpu0_size, cpu0_available_freq, total_count, cpu4_size,cpu4_available_freq, set_group);

	return 0;
}
#define INVALID_ARGV		-1
#define FAILED_OPEN_FILE	-2
#define MAX_AVALLABLE_FREQ	40
#define BUFFER_SIZE			512

#define CPU0_CUR_FREQ_PATH			"/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq"
#define CPU4_CUR_FREQ_PATH			"/sys/devices/system/cpu/cpu4/cpufreq/scaling_cur_freq"
#define CPU0_AVAILABLE_FREQ_PATH	"/sys/devices/system/cpu/cpu0/cpufreq/scaling_available_frequencies"
#define CPU4_AVAILABLE_FREQ_PATH	"/sys/devices/system/cpu/cpu4/cpufreq/scaling_available_frequencies"
#define PROC_CPU_STAT				"/proc/stat"
#define LITTLE_CORE					"/sdcard/little_core"
#define BIG_CORE					"/sdcard/big_core"
#define START_STAT					"/sdcard/stat_start.txt"
#define END_STAT					"/sdcard/stat_end.txt"
#define PCPU_PATH					"/sdcard/stat_result.txt"

typedef signed 		int    si;
typedef signed		char   s8;
typedef unsigned    char   u8;
typedef unsigned	int    ui;
typedef unsigned long int  uli;

计算结果如下：

interval is 100
accummulate_time is 20
time_use is 20596.07
        768000  884000  1000000 1100000 1200000
0       41.64%  45.50%  45.19%  54.13%  52.41%
1       28.25%  28.78%  28.97%  24.77%  42.26%
2       23.41%  24.57%  16.36%  27.08%  46.81%
3       22.34%  15.81%  29.40%  20.00%  20.95%


        768000  1050000 1225000 1400000 1500000 1570000
4       1.07%   5.82%   26.26%  10.00%  20.00%  40.00%
5       0.03%   4.00%   0.00%   0.00%   0.00%   0.00%
6       0.03%   0.00%   0.00%   0.00%   0.00%   0.00%
7       0.00%   0.00%   0.00%   0.00%   0.00%   0.00%


io从

猜你喜欢

转载自blog.csdn.net/feifei_csdn/article/details/80424198
今日推荐
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
报告：Django 仍然是 74% 开发者的首选
《2024 年一季度互联网投融资运行情况》研究报告
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
周排行
BPM为企业带来的实际利益
好程序员web前端分享css常用属性缩写
Java文件下载（excel）
css样式的动态添加及显示和隐藏等零碎用法
axios全局配置以及拦截器
使用Logstash来实时同步MySQL和log日志数据到ES
C++获取当前时间（年月日、时分秒、毫秒）
Odoo产品分析 (四) -- 工具板块(11) -- 网站即时聊天(1)
Java环境配置正确，但是java、javac、java -version均返回“不是内部或外部命令，也不是可运行的程序或批处理文件”？
01 官网下载各种CentOS教程（超详细版）
每日归档
更多
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022