Aren/toaruos
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
55c333d183
toaruos/apps/cpuwidget.c

573 lines
15 KiB
C
Raw Blame History

/**
* @brief System monitor tool
*
* Displays CPU usage, memory usage, and network usage, with nice
* curvy anti-aliased graphs that scroll smoothly.
*
* @copyright
* This file is part of ToaruOS and is released under the terms
* of the NCSA / University of Illinois License - see LICENSE.md
* Copyright (C) 2021 K. Lange
*/
#include <stdlib.h>
#include <assert.h>
#include <unistd.h>
#include <dirent.h>
#include <fcntl.h>
#include <time.h>
#include <sched.h>
#include <math.h>
#include <net/if.h>
#include <sys/ioctl.h>
#include <sys/times.h>
#include <sys/fswait.h>
#include <sys/sysfunc.h>
#include <toaru/yutani.h>
#include <toaru/graphics.h>
#include <toaru/decorations.h>
#include <toaru/text.h>
#include <toaru/menu.h>
static int left, top, width, height;
static yutani_t * yctx;
static yutani_window_t * wina;
static gfx_context_t * ctx_base;
static gfx_context_t * ctx_cpu;
static gfx_context_t * ctx_mem;
static gfx_context_t * ctx_net;
static int left_pad = 0;
static int h_pad = 0;
static int top_pad = 19;
static int bottom_pad = 34;
static int graph_height;
static struct TT_Font * tt_thin = NULL;
static struct TT_Font * tt_bold = NULL;
uint32_t hsv_to_rgb(float h, float s, float v) {
float c = v * s;
float hp = fmod(h, 2 * M_PI);
float x = c * (1.0 - fabs(fmod(hp / 1.0472, 2) - 1.0));
float m = v - c;
float rp, gp, bp;
if (hp <= 1.0472) { rp = c; gp = x; bp = 0; }
else if (hp <= 2.0944) { rp = x; gp = c; bp = 0; }
else if (hp <= 3.1416) { rp = 0; gp = c; bp = x; }
else if (hp <= 4.1888) { rp = 0; gp = x; bp = c; }
else if (hp <= 5.2360) { rp = x; gp = 0; bp = c; }
else { rp = c; gp = 0; bp = x; }
return rgb((rp + m) * 255, (gp + m) * 255, (bp + m) * 255);
}
static int should_exit = 0;
static clock_t last_redraw = 0;
static int cpu_count = 1;
int cpus[32] = {0};
static void get_cpu_info(int cpus[]) {
FILE * f = fopen("/proc/idle","r");
char buf[4096];
fread(buf, 4096, 1, f);
char * buffer = buf;
for (int i = 0; i < cpu_count; ++i) {
/* pid */
char * a = strchr(buffer, ':');
a++;
cpus[i] = strtoul(a, &a, 10);
cpus[i] += strtoul(a, &a, 10);
cpus[i] += strtoul(a, &a, 10);
cpus[i] += strtoul(a, &a, 10);
cpus[i] /= 4;
if (cpus[i] < 0) cpus[i] = 0;
if (cpus[i] > 1000) cpus[i] = 1000;
buffer = strchr(a, '\n');
}
fclose(f);
}
static uint32_t colors[32];
static uint32_t if_colors[32];
#define EASE_WIDTH 8
static void shift_graph(gfx_context_t * ctx) {
for (int y = 0; y < ctx->height; ++y) {
for (int x = 0; x < ctx->width - 1; ++x) {
GFX(ctx,x,y) = GFX(ctx,x+1,y);
}
for (int w = 1; w < 2; ++w) {
GFX(ctx,ctx->width-w,y) = rgb(0xF8,0xF8,0xF8);
}
}
}
extern struct TT_Contour * tt_contour_start(float x, float y);
extern struct TT_Shape * tt_contour_finish(struct TT_Contour * in);
extern struct TT_Contour * tt_contour_line_to(struct TT_Contour * shape, float x, float y);
extern void tt_path_paint(gfx_context_t * ctx, const struct TT_Shape * shape, uint32_t color);
extern void tt_contour_stroke_bounded(gfx_context_t * ctx, struct TT_Contour * in, uint32_t color, float width,
int x_0, int y_0, int w, int h);
static void graph_between(gfx_context_t * ctx, size_t old, size_t new, size_t scale, uint32_t color, int direction) {
static float factor[EASE_WIDTH] = {0.0};
if (factor[0] == 0.0) {
for (int i = 0; i < EASE_WIDTH; ++i) {
factor[i] = (cos(M_PI * ((float)i / (float)(EASE_WIDTH-1))) + 1.0) / 2.0;
}
}
if (old > scale) old = scale;
if (new > scale) new = scale;
static float samples[EASE_WIDTH];
for (int i = 0; i < EASE_WIDTH; ++i) {
size_t value = old * factor[i] + new * (1.0 - factor[i]);
samples[i] = (direction == 0) ? (value * (ctx->height - 1) / (float)scale) : ((scale - value) * (ctx->height - 1) / (float)scale);
}
/* Main line */
struct TT_Contour * contour = tt_contour_start(ctx->width - EASE_WIDTH, samples[0]);
for (int i = 1; i < EASE_WIDTH; ++i) {
contour = tt_contour_line_to(contour, ctx->width - EASE_WIDTH + i, samples[i]);
}
/* Now slow stroke, but only within these bounds */
tt_contour_stroke_bounded(ctx, contour, color, 0.5, ctx->width - EASE_WIDTH, 0, EASE_WIDTH - 1, ctx->height);
/* Now finish the lower part of the graph */
contour = tt_contour_line_to(contour, ctx->width - 1, ctx->height);
contour = tt_contour_line_to(contour, ctx->width - EASE_WIDTH, ctx->height);
struct TT_Shape * shape = tt_contour_finish(contour);
uint32_t c = premultiply(rgba(_RED(color),_GRE(color),_BLU(color),_ALP(color) * 0.25));
tt_path_paint(ctx, shape, c);
free(shape);
free(contour);
}
static void next_cpu(gfx_context_t * ctx) {
int cpus_new[32];
get_cpu_info(cpus_new);
for (int i = 0; i < cpu_count; ++i) {
graph_between(ctx, cpus[i], cpus_new[i], 1000, colors[i], 0);
}
memcpy(cpus, cpus_new, sizeof(cpus_new));
}
static void get_mem_info(int * total, int * used) {
FILE * f = fopen("/proc/meminfo", "r");
if (!f) return;
int free;
char buf[1024] = {0};
fgets(buf, 1024, f);
char * a, * b;
a = strchr(buf, ' ');
a++;
b = strchr(a, '\n');
*b = '\0';
*total = atoi(a);
fgets(buf, 1024, f);
a = strchr(buf, ' ');
a++;
b = strchr(a, '\n');
*b = '\0';
free = atoi(a);
*used = *total - free;
fclose(f);
}
static void next_mem(gfx_context_t * ctx) {
static int total = 0;
static int old_use = 0;
int mem_use = 0;
get_mem_info(&total, &mem_use);
if (!old_use) {
old_use = mem_use;
return;
}
graph_between(ctx, old_use, mem_use, total, rgb(250,110,240), 1);
old_use = mem_use;
}
static char ifnames[32][256];
static int count_interfaces(void) {
int count = 0;
DIR * d = opendir("/dev/net");
if (!d) {
return 0;
}
struct dirent * ent;
while ((ent = readdir(d))) {
if (ent->d_name[0] == '.') continue;
snprintf(ifnames[count>>1], 255, ent->d_name);
count += 2;
}
closedir(d);
return count;
}
static void refresh_interfaces(size_t ifs[32]) {
int ind = 0;
DIR * d = opendir("/dev/net");
if (!d) return;
struct dirent * ent;
while ((ent = readdir(d))) {
if (ent->d_name[0] == '.') continue;
char if_path[1024];
snprintf(if_path, 1023, "/dev/net/%s", ent->d_name);
int netdev = open(if_path, O_RDWR);
if (netdev < 0) {
continue;
}
netif_counters_t counts;
if (!ioctl(netdev, SIOCGIFCOUNTS, &counts)) {
ifs[ind + 0] = counts.rx_bytes;
ifs[ind + 1] = counts.tx_bytes;
ind += 2;
}
close(netdev);
}
closedir(d);
}
static int if_count = -1;
static void next_net(gfx_context_t * ctx) {
static size_t old_ifs[32];
static size_t old_use[32];
static clock_t ticks_last = 0;
size_t new_ifs[32];
size_t new_use[32];
if (!ticks_last) {
ticks_last = times(NULL);
refresh_interfaces(old_ifs);
return;
}
clock_t ticks_now = times(NULL);
refresh_interfaces(new_ifs);
for (int i = 0; i < if_count; ++i) {
/* Kilobits... */
new_use[i] = (new_ifs[i] - old_ifs[i]) * 8 / 1024;
new_use[i] *= CLOCKS_PER_SEC;
new_use[i] /= (ticks_now - ticks_last);
/* Relative to 300mbps... */
graph_between(ctx, old_use[i], new_use[i], 300 * 1024, if_colors[i], 1);
}
memcpy(old_ifs, new_ifs, sizeof(new_ifs));
memcpy(old_use, new_use, sizeof(new_ifs));
ticks_last = ticks_now;
}
static void demarcate(gfx_context_t * ctx) {
for (int y = 0; y < ctx->height; ++y) {
GFX(ctx,ctx->width - 1,y) = rgb(127,127,127);
}
}
static char * ellipsify(char * input, int font_size, struct TT_Font * font, int max_width, int * out_width) {
int len = strlen(input);
char * out = malloc(len + 4);
memcpy(out, input, len + 1);
int width;
tt_set_size(font, font_size);
while ((width = tt_string_width(font, out)) > max_width) {
len--;
out[len+0] = '.';
out[len+1] = '.';
out[len+2] = '.';
out[len+3] = '\0';
}
if (out_width) *out_width = width;
return out;
}
static void draw_legend_element(int which, int count, int index, uint32_t color, char * label) {
struct decor_bounds bounds;
decor_get_bounds(wina, &bounds);
/* Available display width */
int legend_width = ctx_base->width - bounds.width - 40;
if (legend_width <= 0) return;
/* Calculate graph offset from the usual rule */
int y = bounds.top_height + (which + 1) * (top_pad + graph_height) + which * bottom_pad + 4;
/* Space to give to each unit. */
int unit_width = legend_width / count;
/* Left offset of this unit */
int unit_x = unit_width * index + bounds.left_width + 10;
/* First draw blob */
draw_rounded_rectangle(ctx_base,
unit_x, y, 20, 20, 5, color);
if (unit_width > 22) {
char * label_cropped = ellipsify(label, 12, tt_thin, unit_width - 22, NULL);
tt_draw_string(ctx_base, tt_thin, 22 + unit_x, y + 14, label_cropped, rgb(0,0,0));
}
}
static void draw_legend_cpu(void) {
for (int i = 0; i < cpu_count; ++i) {
char _cpu_name[] = "CPU ";
sprintf(_cpu_name, "CPU %d", i+1);
draw_legend_element(0, cpu_count, i, colors[i], _cpu_name);
}
}
static void draw_legend_mem(void) {
draw_legend_element(1, 1, 0, rgb(250,110,240), "Memory Usage");
}
static void draw_legend_net(void) {
for (int i = 0; i < if_count; ++i) {
char _net_name[300];
sprintf(_net_name, "%s (%s)", (i & 1) ? "TX" : "RX", ifnames[i>>1]);
draw_legend_element(2, if_count, i, if_colors[i], _net_name);
}
}
static void refresh(clock_t ticks) {
static int poll_tick = 0;
static clock_t last_line = 0;
/* Shift graphs */
shift_graph(ctx_cpu);
shift_graph(ctx_mem);
shift_graph(ctx_net);
if (ticks > last_line + CLOCKS_PER_SEC * 10) {
demarcate(ctx_cpu);
demarcate(ctx_mem);
demarcate(ctx_net);
last_line = ticks;
}
if (poll_tick == (EASE_WIDTH-2)) {
next_cpu(ctx_cpu);
next_mem(ctx_mem);
next_net(ctx_net);
poll_tick = 0;
} else {
poll_tick++;
}
flip(ctx_base);
yutani_flip(yctx, wina);
last_redraw = ticks;
}
static void initial_stuff(void) {
struct decor_bounds bounds;
decor_get_bounds(wina, &bounds);
graph_height = (height - top_pad * 3 - bottom_pad * 3) / 3;
draw_fill(ctx_base, rgb(204,204,204));
ctx_cpu = init_graphics_subregion(ctx_base, bounds.left_width + left_pad, bounds.top_height + top_pad, width - h_pad, graph_height);
ctx_mem = init_graphics_subregion(ctx_base, bounds.left_width + left_pad, bounds.top_height + 2 * top_pad + graph_height + bottom_pad, width - h_pad, graph_height);
ctx_net = init_graphics_subregion(ctx_base, bounds.left_width + left_pad, bounds.top_height + 3 * top_pad + 2 * graph_height + 2 * bottom_pad, width - h_pad, graph_height);
draw_fill(ctx_cpu, rgb(0xF8,0xF8,0xF8));
draw_fill(ctx_mem, rgb(0xF8,0xF8,0xF8));
draw_fill(ctx_net, rgb(0xF8,0xF8,0xF8));
tt_set_size(tt_bold, 13);
tt_draw_string(ctx_base, tt_bold, bounds.left_width + 3, bounds.top_height + 14, "CPU", rgb(0,0,0));
tt_draw_string(ctx_base, tt_bold, bounds.left_width + 3, bounds.top_height + (top_pad + bottom_pad + graph_height) + 14, "Memory", rgb(0,0,0));
tt_draw_string(ctx_base, tt_bold, bounds.left_width + 3, bounds.top_height + 2 * (top_pad + bottom_pad + graph_height) + 14, "Network", rgb(0,0,0));
tt_set_size(tt_thin, 10);
tt_draw_string(ctx_base, tt_thin, bounds.left_width + width - 30, bounds.top_height + 17, "100%", rgb(0,0,0));
tt_draw_string(ctx_base, tt_thin, bounds.left_width + width - 30, bounds.top_height + (top_pad + bottom_pad + graph_height) + 17, "100%", rgb(0,0,0));
tt_draw_string(ctx_base, tt_thin, bounds.left_width + width - 50, bounds.top_height + 2 * (top_pad + bottom_pad + graph_height) + 17, "300mbps", rgb(0,0,0));
tt_draw_string(ctx_base, tt_thin, bounds.left_width + width - 25, bounds.top_height + top_pad + graph_height + 13, "0%", rgb(0,0,0));
tt_draw_string(ctx_base, tt_thin, bounds.left_width + width - 25, bounds.top_height + 2 * (top_pad + graph_height) + bottom_pad + 13, "0%", rgb(0,0,0));
tt_draw_string(ctx_base, tt_thin, bounds.left_width + width - 40, bounds.top_height + 3 * (top_pad + graph_height) + 2 * bottom_pad + 13, "0mbps", rgb(0,0,0));
render_decorations(wina, ctx_base, "System Monitor");
draw_legend_cpu();
draw_legend_mem();
draw_legend_net();
}
void resize_finish(int w, int h) {
if (w < 300) w = 300;
if (h < 300) h = 300;
free(ctx_cpu);
free(ctx_mem);
free(ctx_net);
yutani_window_resize_accept(yctx, wina, w, h);
reinit_graphics_yutani(ctx_base, wina);
struct decor_bounds bounds;
decor_get_bounds(wina, &bounds);
width = w - bounds.left_width - bounds.right_width;
height = h - bounds.top_height - bounds.bottom_height;
initial_stuff();
flip(ctx_base);
yutani_window_resize_done(yctx, wina);
}
int main (int argc, char ** argv) {
left = 100;
top = 100;
width = 640;
height = 480;
cpu_count = sysfunc(TOARU_SYS_FUNC_NPROC, NULL);
yctx = yutani_init();
if (!yctx) {
fprintf(stderr, "%s: failed to connect to compositor\n", argv[0]);
return 1;
}
srand(time(NULL));
for (int i = 0; i < cpu_count; ++i) {
colors[i] = hsv_to_rgb((float)i / (float)cpu_count * 6.24, 0.9, 0.9);
}
init_decorations();
struct decor_bounds bounds;
decor_get_bounds(NULL, &bounds);
wina = yutani_window_create(yctx, width + bounds.width, height + bounds.height);
yutani_window_move(yctx, wina, left, top);
yutani_window_advertise_icon(yctx, wina, "System Monitor", "system-monitor");
ctx_base = init_graphics_yutani_double_buffer(wina);
tt_thin = tt_font_from_shm("sans-serif");
tt_bold = tt_font_from_shm("sans-serif.bold");
get_cpu_info(cpus);
if_count = count_interfaces();
for (int i = 0; i < if_count; ++i) {
if_colors[i] = hsv_to_rgb((float)i / (float)(if_count)* 6.24 + 0.2, 0.9, 0.9);
}
initial_stuff();
refresh(times(NULL));
while (!should_exit) {
int fds[1] = {fileno(yctx->sock)};
int index = fswait2(1,fds,20);
if (index == 0) {
yutani_msg_t * m = yutani_poll(yctx);
while (m) {
if (menu_process_event(yctx, m)) {
/* just decorations should be fine */
render_decorations(wina, ctx_base, "System Monitor");
flip(ctx_base);
yutani_flip(yctx, wina);
}
switch (m->type) {
case YUTANI_MSG_KEY_EVENT:
{
struct yutani_msg_key_event * ke = (void*)m->data;
if (ke->event.action == KEY_ACTION_DOWN && ke->event.keycode == 'q') {
should_exit = 1;
sched_yield();
}
}
break;
case YUTANI_MSG_WINDOW_FOCUS_CHANGE:
{
struct yutani_msg_window_focus_change * wf = (void*)m->data;
yutani_window_t * win = hashmap_get(yctx->windows, (void*)(uintptr_t)wf->wid);
if (win == wina) {
win->focused = wf->focused;
render_decorations(wina, ctx_base, "System Monitor");
flip(ctx_base);
yutani_flip(yctx, wina);
}
}
break;
case YUTANI_MSG_RESIZE_OFFER:
{
struct yutani_msg_window_resize * wr = (void*)m->data;
resize_finish(wr->width, wr->height);
}
break;
case YUTANI_MSG_WINDOW_MOUSE_EVENT:
{
struct yutani_msg_window_mouse_event * me = (void*)m->data;
yutani_window_t * win = hashmap_get(yctx->windows, (void*)(uintptr_t)me->wid);
if (win == wina) {
int result = decor_handle_event(yctx, m);
switch (result) {
case DECOR_CLOSE:
should_exit = 1;
break;
case DECOR_RIGHT:
/* right click in decoration, show appropriate menu */
decor_show_default_menu(wina, wina->x + me->new_x, wina->y + me->new_y);
break;
default:
/* Other actions */
break;
}
}
}
break;
case YUTANI_MSG_WINDOW_CLOSE:
case YUTANI_MSG_SESSION_END:
should_exit = 1;
break;
default:
break;
}
free(m);
m = yutani_poll_async(yctx);
}
}
clock_t ticks = times(NULL);
if (ticks > last_redraw + CLOCKS_PER_SEC/12) {
refresh(ticks);
}
}
yutani_close(yctx, wina);
return 0;
}
Reference in New Issue View Git Blame Copy Permalink