计算linux下cpu及内存工作情况

代码：

 

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#include "machine.h"
#include "top.h"
#include "os.h"
#include "utils.h"

//#define HASH_SIZE 1024
#define NR_TASKS 1024;

#define PROCFS "/proc"
extern char *myname;
extern uid_t proc_owner(pid_t pid);

 

/*=STATE IDENT STRINGS==================================================*/

#define NPROCSTATES 7
static char *state_abbrev[NPROCSTATES+1] =
{
    "", "run", "sleep", "disk", "zomb", "stop", "swap",
    NULL
};

static char *procstatenames[NPROCSTATES+1] =
{
    "", " running, ", " sleeping, ", " uninterruptable, ",
    " zombie, ", " stopped, ", " swapping, ",
    NULL
};

#define NCPUSTATES 4
static char *cpustatenames[NCPUSTATES+1] =
{
    "user", "nice", "system", "idle",
    NULL
};

#define NMEMSTATS 6
static char *memorynames[NMEMSTATS+1] =
{
    "K used, ", "K free, ", "K shd, ", "K buf  Swap: ",
    "K used, ", "K free",
    NULL
};

static char fmt_header[] =
"  PID X        PRI NICE  SIZE   RES STATE   TIME   WCPU    CPU COMMAND";

/*=SYSTEM STATE INFO====================================================*/

/* these are for calculating cpu state percentages */

static long cp_time[NCPUSTATES];
static long cp_old[NCPUSTATES];
static long cp_diff[NCPUSTATES];

/* these are for keeping track of processes */

#define HASH_SIZE (NR_TASKS * 3 / 2)

static struct top_proc **nextactive;

/* these are for passing data back to the machine independant portion */

static int cpu_states[NCPUSTATES];
static int memory_stats[NMEMSTATS];

/* usefull macros */
#define bytetok(x) (((x) + 512) >> 10)
#define pagetok(x) ((x) << (PAGE_SHIFT - 10))
#define HASH(x)  (((x) * 1686629713U) % HASH_SIZE)

/*======================================================================*/

/*
 *  percentages(cnt, out, new, old, diffs) - calculate percentage change
 * between array "old" and "new", putting the percentages i "out".
 * "cnt" is size of each array and "diffs" is used for scratch space.
 * The array "old" is updated on each call.
 * The routine assumes modulo arithmetic.  This function is especially
 * useful on BSD mchines for calculating cpu state percentages.
 */

long percentages(cnt, out, new, old, diffs)

int cnt;
int *out;
register long *new;
register long *old;
long *diffs;

{
    register int i;
    register long change;
    register long total_change;
    register long *dp;
    long half_total;

    /* initialization */
    total_change = 0;
    dp = diffs;

    /* calculate changes for each state and the overall change */
    for (i = 0; i < cnt; i++)
    {
 if ((change = *new - *old) < 0)
 {
     /* this only happens when the counter wraps */
     change = (int)
  ((unsigned long)*new-(unsigned long)*old);
 }
 total_change += (*dp++ = change);
 *old++ = *new++;
    }

    /* avoid divide by zero potential */
    if (total_change == 0)
    {
 total_change = 1;
    }

    /* calculate percentages based on overall change, rounding up */
    half_total = total_change / 2l;
    for (i = 0; i < cnt; i++)
    {
 *out++ = (int)((*diffs++ * 1000 + half_total) / total_change);
    }

    /* return the total in case the caller wants to use it */
    return(total_change);
}

static inline char *
skip_token(const char *p)
{
    while (isspace(*p)) p++;
    while (*p && !isspace(*p)) p++;
    return (char *)p;
}

static inline char *
skip_ws(const char *p)
{
    while (isspace(*p)) p++;
    return (char *)p;
}

void get_system_info(info)
    struct system_info *info;
{
    char buffer[4096+1];
    int fd, len;
    char *p;
    int i;

    /* get load averages */
    {
 fd = open("/proc/loadavg", O_RDONLY);
 len = read(fd, buffer, sizeof(buffer)-1);
 close(fd);
 buffer[len] = '/0';

 info->load_avg[0] = strtod(buffer, &p);
 info->load_avg[1] = strtod(p, &p);
 info->load_avg[2] = strtod(p, &p);
 p = skip_token(p);   /* skip running/tasks */
 p = skip_ws(p);
 if (*p)
     info->last_pid = atoi(p);
 else
     info->last_pid = -1;
    }

    /* get the cpu time info */
    {
 fd = open("/proc/stat", O_RDONLY);
 len = read(fd, buffer, sizeof(buffer)-1);
 close(fd);
 buffer[len] = '/0';

 p = skip_token(buffer);   /* "cpu" */
 cp_time[0] = strtoul(p, &p, 0);
 
 cp_time[1] = strtoul(p, &p, 0);
 cp_time[2] = strtoul(p, &p, 0);
 cp_time[3] = strtoul(p, &p, 0);

 /* convert cp_time counts to percentages
  after this funcation, cpu_states[0] stores the percentage of used cpu
 */
 percentages(4, cpu_states, cp_time, cp_old, cp_diff);
    }
 
    /* get system wide memory usage */
    {
 char *p;

 fd = open("/proc/meminfo", O_RDONLY);
 len = read(fd, buffer, sizeof(buffer)-1);
 close(fd);
 buffer[len] = '/0';

 /* be prepared for extra columns to appear be seeking
    to ends of lines */
 
 p = buffer;
 p = skip_token(p);
 memory_stats[0] = strtoul(p, &p, 10); /* total memory */
 
 p = strchr(p, '/n');
 p = skip_token(p);
 memory_stats[1] = strtoul(p, &p, 10); /* free memory */
 
 
 p = strchr(p, '/n');
 p = skip_token(p);
 memory_stats[2] = strtoul(p, &p, 10); /* buffer memory */
 
 p = strchr(p, '/n');
 p = skip_token(p);
 memory_stats[3] = strtoul(p, &p, 10); /* cached memory */
 
 for(i = 0; i< 8 ;i++) {
  p++;
  p = strchr(p, '/n');
 }
 
 p = skip_token(p);
 memory_stats[4] = strtoul(p, &p, 10); /* total swap */
 
 p = strchr(p, '/n');
 p = skip_token(p);
 memory_stats[5] = strtoul(p, &p, 10); /* free swap */
 
    }

    /* set arrays and strings */
    info->cpustates = cpu_states;
    info->memory = memory_stats;
}

int main_old()
{
 int i;
  struct system_info info;
  get_system_info(&info);
 
 for(i=0;i<3;i++){
  if(i==2){
   printf("Used CPU:%.1f%%/n",(float)info.cpustates[0]/10);
   printf("Nice CPU:%.1f%%/n",(float)info.cpustates[1]/10);
   printf("System CPU:%.1f%%/n",(float)info.cpustates[2]/10);
   printf("Idle CPU:%.1f%%/n",(float)info.cpustates[3]/10);
  
   printf("total memroy:%d/n", info.memory[0]);
   printf("free memroy:%d/n", info.memory[1]);
   printf("buffers:%d/n", info.memory[2]);
   printf("cached:%d/n", info.memory[3]);
   printf("total swap:%d/n", info.memory[4]);
   printf("free swap:%d/n", info.memory[5]);
    printf("................................../n");
 }

   sleep(2);
     get_system_info(&info);
     }

 
 return 0;
}

int main()
{
 int i;
  struct system_info info;
  get_system_info(&info);
 
 for(i=0;i<3;i++){
  if(i==2){
   /*
   printf("Used CPU:%.1f%%/n",(float)info.cpustates[0]/10);
   printf("Nice CPU:%.1f%%/n",(float)info.cpustates[1]/10);
   printf("System CPU:%.1f%%/n",(float)info.cpustates[2]/10);
   printf("Idle CPU:%.1f%%/n",(float)info.cpustates[3]/10);
  
   printf("total memroy:%d/n", info.memory[0]);
   printf("free memroy:%d/n", info.memory[1]);
   printf("buffers:%d/n", info.memory[2]);
   printf("cached:%d/n", info.memory[3]);
   printf("total swap:%d/n", info.memory[4]);
   printf("free swap:%d/n", info.memory[5]);
    printf("................................../n");
   printf("Used CPU:%.1f%%/n",(float)info.cpustates[0]/10);
   printf("Used CPU:%.1f%%/n",(float)info.cpustates[0]);
   printf("Used CPU:%.1f%%/n",(float)info.cpustates[0]/10);
    */
   printf("%d/n",(int)info.cpustates[0]);  //
  return 0;
  }

  sleep(2);
  get_system_info(&info);
 }

 
 return (float)0;
}