154 lines
3.2 KiB
C
154 lines
3.2 KiB
C
/*
|
|
* Copyright (C) 2022-2023 Artinchip Technology Co., Ltd.
|
|
* Authors: Ning Fang <ning.fang@artinchip.com>
|
|
*/
|
|
|
|
#include <unistd.h>
|
|
#include <stdint.h>
|
|
#include <time.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include "model_base.h"
|
|
#include "lv_port_disp.h"
|
|
|
|
struct cpu_occupy
|
|
{
|
|
unsigned long user;
|
|
unsigned long nice;
|
|
unsigned long system;
|
|
unsigned long idle;
|
|
};
|
|
|
|
struct memory_occupy
|
|
{
|
|
unsigned long total;
|
|
unsigned long free;
|
|
unsigned long available;
|
|
unsigned long buffers;
|
|
unsigned long cached;
|
|
};
|
|
|
|
static int mem_occupy_get(struct memory_occupy *mem)
|
|
{
|
|
FILE *fd;
|
|
char mem_cached[256];
|
|
char mem_total[256];
|
|
char mem_free[256];
|
|
char mem_available[256];
|
|
char mem_buffers[256];
|
|
|
|
fd = fopen ("/proc/meminfo", "r");
|
|
|
|
if (!fd) {
|
|
return -1;
|
|
}
|
|
|
|
/* MemTotal */
|
|
fgets(mem_total, sizeof(mem_total), fd);
|
|
mem->total = atoi(mem_total + 15);
|
|
|
|
/* MemFree */
|
|
fgets (mem_free, sizeof(mem_free), fd);
|
|
mem->free = atoi(mem_free + 15);
|
|
|
|
/* MemAvailable */
|
|
fgets (mem_available, sizeof(mem_available), fd);
|
|
mem->available = atoi(mem_available + 15);
|
|
|
|
/* Buffers */
|
|
fgets(mem_buffers, sizeof(mem_buffers), fd);
|
|
mem->buffers = atoi(mem_buffers + 15);
|
|
|
|
/* Cached */
|
|
fgets(mem_cached, sizeof(mem_cached), fd);
|
|
mem->cached = atoi(mem_cached + 15);
|
|
|
|
fclose(fd);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static float mem_occupy_cal_size(struct memory_occupy *mem)
|
|
{
|
|
return (float) ((mem->total - mem->free - mem->buffers - mem->cached) / 1024.0);
|
|
}
|
|
|
|
static int cpu_occupy_get(struct cpu_occupy *t)
|
|
{
|
|
FILE *fd;
|
|
char buff[1024] = { 0 };
|
|
char name[64]={ 0 };
|
|
|
|
fd = fopen("/proc/stat","r");
|
|
|
|
if (!fd) {
|
|
return -1;
|
|
}
|
|
|
|
fgets(buff,sizeof(buff), fd);
|
|
sscanf(buff,"%s %lu %lu %lu %lu", name, &t->user, &t->nice, &t->system, &t->idle);
|
|
fclose(fd);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static float cpu_occupy_cal(struct cpu_occupy *o, struct cpu_occupy *n)
|
|
{
|
|
unsigned long od, nd;
|
|
unsigned long id, sd;
|
|
float cpu_use = 0;
|
|
|
|
od = (unsigned long)(o->user + o->nice + o->system + o->idle);
|
|
nd = (unsigned long)(n->user + n->nice + n->system + n->idle);
|
|
id = (unsigned long)(n->user - o->user);
|
|
sd = (unsigned long)(n->system - o->system);
|
|
|
|
if ((nd - od) != 0)
|
|
cpu_use = (float)((sd + id)*100) / (float)(nd - od);
|
|
|
|
return cpu_use;
|
|
}
|
|
|
|
int get_fb_draw_fps(void)
|
|
{
|
|
return fbdev_draw_fps();
|
|
}
|
|
|
|
float get_cpu_usage(void)
|
|
{
|
|
static int first_cal_cpu = 0;
|
|
static int cpu_cal_id = 0;
|
|
static struct cpu_occupy cpu_stat[2];
|
|
int last_id = 0;
|
|
float cpu_usage = 0;
|
|
|
|
/* cpu usage */
|
|
last_id = (cpu_cal_id == 1) ? 0 : 1;
|
|
if (first_cal_cpu)
|
|
cpu_occupy_get((struct cpu_occupy *)&cpu_stat[last_id]);
|
|
|
|
cpu_occupy_get((struct cpu_occupy *)&cpu_stat[cpu_cal_id]);
|
|
cpu_usage = cpu_occupy_cal((struct cpu_occupy *)&cpu_stat[last_id],
|
|
(struct cpu_occupy *)&cpu_stat[cpu_cal_id]);
|
|
|
|
if (cpu_usage >= 30.0) {
|
|
cpu_usage -= 10.0;
|
|
}
|
|
|
|
cpu_cal_id = last_id;
|
|
|
|
return cpu_usage;
|
|
}
|
|
|
|
float get_mem_usage(void)
|
|
{
|
|
static struct memory_occupy mem_stat = {0};
|
|
float mem_usage = 0;
|
|
|
|
mem_occupy_get(&mem_stat);
|
|
mem_usage = mem_occupy_cal_size(&mem_stat);
|
|
|
|
return mem_usage;
|
|
}
|