wmcpuwatch.c

Go to the documentation of this file.

/*
    wmcpuwatch - WindowMaker dock app to watch all CPUs of a system
    Copyright (C) 2017 Andreas Tscharner <andy@vis.ethz.ch>

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#define _GNU_SOURCE      
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include <sys/wait.h>

#include <libdockapp/wmgeneral.h>
#include <libdockapp/misc.h>

#include "ulllib.h"
#include "wmcpuwatch-master.xpm"
#include "wmcpuwatch-mask.xbm"

#include "config.h"

#define MAX_CPU (40)     
#define MAX_HEIGHT (9)   
/* Type definition */

typedef struct {
    long rt_stat;        
    ullong statlast;     
    long rt_idle;        
    ullong idlelast;     
    /* Processors stats */
    long *cpu_stat;      
    ullong *cpu_last;    
    long *idle_stat;     
    ullong *idle_last;   
} stat_dev;


/* Forward declarations
   See the implementation for detailed description */
void usage(char*);
void print_version(void);
void wmcpuwatch(int, char **);
void clear_widgets(void);
void initialize_stat_device(stat_dev *, int, const char *);
int get_number_of_CPU(FILE *);
void get_statistics(FILE *, ullong *, ullong *, ullong *, ullong *);
void update_stat_cpu(FILE *, stat_dev *, ullong *, ullong *, int);
unsigned long get_width(long, long, long);


int main(int argc, char *argv[])
{
    char *name = argv[0];

    /* Parse Command Line */
    for (int i = 1; i < argc; i++) {
        char *arg = argv[i];

        if (*arg=='-')
            switch (arg[1]) {
            case 'd' :
                if (strcmp(arg+1, "display")) {
                    usage(name);
                    return 1;
                }
                break;
            case 'g' :
                if (strcmp(arg+1, "geometry")) {
                    usage(name);
                    return 1;
                }
            case 'v' :
                print_version();
                return 0;
            default:
                usage(name);
                return 1;
            }
    }

    wmcpuwatch(argc, argv);
    exit(0);
}


void wmcpuwatch(int argc, char **argv)
{
    FILE *fp_stat;
    XEvent Event;
    ullong istat, idle, *istat2, *idle2;
    stat_dev stat_device;
    int nb_cpu;


    fp_stat = fopen("/proc/stat", "r");
    nb_cpu = get_number_of_CPU(fp_stat);

    initialize_stat_device(&stat_device, nb_cpu, argv[0]);

    istat2 = calloc(nb_cpu, sizeof(ullong));
    idle2 = calloc(nb_cpu, sizeof(ullong));
    if (!istat2 || !idle2) {
        fprintf(stderr, "%s: Unable to alloc memory !!\n", argv[0]);
        exit(1);
    }

    openXwindow(argc, argv, wmcpuwatch_master_xpm, (char *)wmcpuwatch_mask_bits,
        wmcpuwatch_mask_width, wmcpuwatch_mask_height);

    /* Collect information on each panel */
    get_statistics(fp_stat, &istat, &idle, istat2, idle2);
    stat_device.statlast = istat;
    stat_device.idlelast = idle;

    for (int cpu = 0; cpu < nb_cpu; cpu++) {
        stat_device.cpu_last[cpu] = istat2[cpu];
        stat_device.idle_last[cpu] = idle2[cpu];
    }

    while (1) {
        waitpid(0, NULL, WNOHANG);

        update_stat_cpu(fp_stat, &stat_device, istat2, idle2, nb_cpu);

        /* Clear both widgets */
        clear_widgets();

        /* show average CPU */
        int j = get_width(stat_device.rt_stat, stat_device.rt_idle, 32);
        copyXPMArea(32, 64, j, 12, 28, 4);

        /* show all CPUs */
        int h = (MAX_CPU / nb_cpu) > MAX_HEIGHT ? MAX_HEIGHT : MAX_CPU / nb_cpu;
        for (int cpu = 0; cpu < nb_cpu; cpu++) {
            j = get_width(stat_device.cpu_stat[cpu], stat_device.idle_stat[cpu], 56);
            copyXPMArea(1, 95, j, h, 5, 19 + h * cpu);
        }

        RedrawWindow();

        while (XPending(display)) {
            XNextEvent(display, &Event);
            switch (Event.type) {
                case Expose:
                    RedrawWindow();
                    break;
                case DestroyNotify:
                    XCloseDisplay(display);
                    exit(0);
                    break;
            }
        }
        usleep(250000L);
    }

    fclose(fp_stat);
}


void clear_widgets(void)
{
        /* Clear average load */
        copyXPMArea(0, 64, 32, 12, 28,  4);

        /* Clear full field */
        copyXPMArea(0, 80, 56, 10,  4, 18);
        copyXPMArea(0, 81, 56,  9,  4, 27);
        copyXPMArea(0, 81, 56,  9,  4, 36);
        copyXPMArea(0, 81, 56,  9,  4, 45);
        copyXPMArea(0, 81, 56,  4,  4, 54);
        copyXPMArea(0, 75, 56,  1,  4, 58);
}

void initialize_stat_device(stat_dev *statdevice, int cpucount, const char *dockappname)
{
    statdevice->cpu_stat = calloc(cpucount, sizeof(long));
    statdevice->cpu_last = calloc(cpucount, sizeof(ullong));
    statdevice->idle_stat = calloc(cpucount, sizeof(long));
    statdevice->idle_last = calloc(cpucount, sizeof(ullong));
    if (!statdevice->cpu_stat ||
        !statdevice->cpu_last ||
        !statdevice->idle_stat ||
        !statdevice->idle_last) {
            fprintf(stderr, "%s: Unable to alloc memory !\n", dockappname);
            exit(1);
    }
}

void update_stat_cpu(FILE *fpstat, stat_dev *st, ullong *istat2, ullong *idle2, int cpucount)
{
    ullong istat, idle;

    get_statistics(fpstat, &istat, &idle, istat2, idle2);

    st->rt_idle = ullsub(&idle, &st->idlelast);
    st->idlelast = idle;

    st->rt_stat = ullsub(&istat, &st->statlast);
    st->statlast = istat;

    for (int cpu = 0; cpu < cpucount; cpu++) {
        st->idle_stat[cpu] = ullsub(&idle2[cpu], &st->idle_last[cpu]);
        st->idle_last[cpu] = idle2[cpu];

        st->cpu_stat[cpu] = ullsub(&istat2[cpu], &st->cpu_last[cpu]);
        st->cpu_last[cpu] = istat2[cpu];
    }
}


void get_statistics(FILE *fpstat, ullong *ds, ullong *idle, ullong *ds2, ullong *idle2)
{
    static char *line = NULL;
    static size_t line_size = 0;
    char *p;
    char *tokens = " \t\n";
    ullong ulltmp;


    ullreset(ds);
    ullreset(idle);

    fseek(fpstat, 0, SEEK_SET);
    while ((getline(&line, &line_size, fpstat)) > 0) {
        if (strstr(line, "cpu")) {
            int cpu = -1;   /* by default, cumul stats => average */
            if (!strstr(line, "cpu ")) {
                sscanf(line, "cpu%d", &cpu);
                ullreset(&ds2[cpu]);
                ullreset(&idle2[cpu]);
            }

            p = strtok(line, tokens);
            /* 1..3, 4 == idle, we don't want idle! */
            for (int i=0; i<3; i++) {
                p = strtok(NULL, tokens);
                ullparse(&ulltmp, p);
                if (cpu == -1)
                    ulladd(ds, &ulltmp);
                else
                    ulladd(&ds2[cpu], &ulltmp);
            }

            p = strtok(NULL, tokens);
            if (cpu == -1)
                ullparse(idle, p);
            else
                ullparse(&idle2[cpu], p);
        }
    }
}


unsigned long get_width(long actif, long idle, long line_len)
{
    /* wbk - work with a decimal value so we don't round < 1 down to zero.  */
    double j = 0;

    j = (actif + idle);
    if (j != 0)
        j = (actif * 100) / j;

    j = j * (double)(line_len / 100.0);

    /* round up very low positive values so they are visible. */
    if (actif > 0 && j < 2)
        j = 2;

    if (j > line_len)
        j = (double)line_len;

    return (unsigned long) j;
}


int get_number_of_CPU(FILE *fpstat)
{
    static char *line = NULL;
    static size_t line_size = 0;
    int cpu = 0;

    fseek(fpstat, 0, SEEK_SET);
    while ((getline(&line, &line_size, fpstat)) > 0) {
        if (strstr(line, "cpu") && !strstr(line, "cpu "))
            sscanf(line, "cpu%d", &cpu);
    }

    return cpu+1;
}


void usage(char *name)
{
    printf("\n    wmcpuwatch  Copyright (C) 2017  Andreas Tscharner\n");
    printf("    This program comes with ABSOLUTELY NO WARRANTY;\n");
    printf("    This is free software, and you are welcome to\n");
    printf("    redistribute it under certain conditions;\n");
    printf("\n\n");
    printf("Usage: %s [OPTION]...\n", name);
    printf("WindowMaker dockapp that displays the cpu load of all CPUs.\n");
    printf("  -display DISPLAY     contact the DISPLAY X server\n");
    printf("  -geometry GEOMETRY   position the dockapp at GEOMETRY\n");
    printf("  -h                   display this help and exit\n");
    printf("  -v                   output version information and exit\n");
}


void print_version(void)
{
    printf("wmcpuwatch version %s\n", PACKAGE_VERSION);
}