gnunet-service-testbed_cpustatus.c File Reference

calls to determine current CPU load More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet-service-testbed_meminfo.h"

Include dependency graph for gnunet-service-testbed_cpustatus.c:

Go to the source code of this file.

Macros
#define	DEBUG_STATUSCALLS   GNUNET_NO

Functions
static int	updateUsage ()
	Update the currentCPU and currentIO load (and on Linux, memory) values. More...
static void	updateAgedLoad ()
	Update load values (if enough time has expired), including computation of averages. More...
static int	cpu_get_load ()
	Get the load of the CPU relative to what is allowed. More...
static int	disk_get_load ()
	Get the load of the CPU relative to what is allowed. More...
static unsigned int	mem_get_usage ()
	Get the percentage of memory used. More...
static void	sample_load_task (void *cls)
void	GST_stats_init (const struct GNUNET_CONFIGURATION_Handle *cfg)
	Initialize logging CPU and IO statisticfs. More...
void	GST_stats_destroy ()
	Shutdown the status calls module. More...

Variables
static int	currentCPULoad
	Current CPU load, as percentage of CPU cycles not idle or blocked on IO. More...
static double	agedCPULoad = -1
static int	currentIOLoad
	Current IO load, as percentage of CPU cycles blocked on IO. More...
static double	agedIOLoad = -1
struct GNUNET_BIO_WriteHandle *	bw
	handle to the file to write the load statistics to More...
struct GNUNET_SCHEDULER_Task *	sample_load_task_id

Detailed Description

calls to determine current CPU load

Author

Tzvetan Horozov

Christian Grothoff

Igor Wronsky

Alex Harper (OS X portion)

Sree Harsha Totakura

Definition in file gnunet-service-testbed_cpustatus.c.

Macro Definition Documentation

DEBUG_STATUSCALLS

#define DEBUG_STATUSCALLS   GNUNET_NO

Definition at line 58 of file gnunet-service-testbed_cpustatus.c.

Function Documentation

updateUsage()

static int updateUsage ( )

static

Update the currentCPU and currentIO load (and on Linux, memory) values.

Before its first invocation the method initStatusCalls() must be called. If there is an error the method returns -1.

Definition at line 132 of file gnunet-service-testbed_cpustatus.c.

{
  currentIOLoad = -1;
  currentCPULoad = -1;
#ifdef __linux__
  /* under linux, first try %idle/usage using /proc/stat;
     if that does not work, disable /proc/stat for the future
     by closing the file and use the next-best method. */
  if (proc_stat != NULL)
  {
    static unsigned long long last_cpu_results[5] = { 0, 0, 0, 0, 0 };
    static int have_last_cpu = GNUNET_NO;
    int ret;
    char line[256];
    unsigned long long user_read, system_read, nice_read, idle_read,
                       iowait_read;
    unsigned long long user, system, nice, idle, iowait;
    unsigned long long usage_time = 0, total_time = 1;
 
    /* Get the first line with the data */
    rewind (proc_stat);
    fflush (proc_stat);
    if (NULL == fgets (line, 256, proc_stat))
    {
      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
                                "fgets", "/proc/stat");
      proc_stat = NULL;         /* don't try again */
    }
    else
    {
      iowait_read = 0;
      ret = sscanf (line, "%*s %llu %llu %llu %llu %llu",
                    &user_read,
                    &system_read, &nice_read, &idle_read, &iowait_read);
      if (ret < 4)
      {
        GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
                                  "fgets-sscanf", "/proc/stat");
        fclose (proc_stat);
        proc_stat = NULL;       /* don't try again */
        have_last_cpu = GNUNET_NO;
      }
      else
      {
        /* Store the current usage */
        user = user_read - last_cpu_results[0];
        system = system_read - last_cpu_results[1];
        nice = nice_read - last_cpu_results[2];
        idle = idle_read - last_cpu_results[3];
        iowait = iowait_read - last_cpu_results[4];
        /* Calculate the % usage */
        usage_time = user + system + nice;
        total_time = usage_time + idle + iowait;
        if ((total_time > 0) && (have_last_cpu == GNUNET_YES))
        {
          currentCPULoad = (int) (100L * usage_time / total_time);
          if (ret > 4)
            currentIOLoad = (int) (100L * iowait / total_time);
          else
            currentIOLoad = -1;         /* 2.4 kernel */
        }
        /* Store the values for the next calculation */
        last_cpu_results[0] = user_read;
        last_cpu_results[1] = system_read;
        last_cpu_results[2] = nice_read;
        last_cpu_results[3] = idle_read;
        last_cpu_results[4] = iowait_read;
        have_last_cpu = GNUNET_YES;
        return GNUNET_OK;
      }
    }
  }
#endif
 
#ifdef OSX
  {
    unsigned int cpu_count;
    processor_cpu_load_info_t cpu_load;
    mach_msg_type_number_t cpu_msg_count;
    unsigned long long t_sys, t_user, t_nice, t_idle, t_total;
    unsigned long long t_idle_all, t_total_all;
    kern_return_t kret;
    int i, j;
 
    t_idle_all = t_total_all = 0;
    kret = host_processor_info (mach_host_self (), PROCESSOR_CPU_LOAD_INFO,
                                &cpu_count,
                                (processor_info_array_t *) &cpu_load,
                                &cpu_msg_count);
    if (kret == KERN_SUCCESS)
    {
      for (i = 0; i < cpu_count; i++)
      {
        if (cpu_load[i].cpu_ticks[CPU_STATE_SYSTEM] >=
            prev_cpu_load[i].cpu_ticks[CPU_STATE_SYSTEM])
        {
          t_sys = cpu_load[i].cpu_ticks[CPU_STATE_SYSTEM]
                  - prev_cpu_load[i].cpu_ticks[CPU_STATE_SYSTEM];
        }
        else
        {
          t_sys = cpu_load[i].cpu_ticks[CPU_STATE_SYSTEM]
                  + (ULONG_MAX - prev_cpu_load[i].cpu_ticks[CPU_STATE_SYSTEM]
                     + 1);
        }
 
        if (cpu_load[i].cpu_ticks[CPU_STATE_USER] >=
            prev_cpu_load[i].cpu_ticks[CPU_STATE_USER])
        {
          t_user = cpu_load[i].cpu_ticks[CPU_STATE_USER]
                   - prev_cpu_load[i].cpu_ticks[CPU_STATE_USER];
        }
        else
        {
          t_user = cpu_load[i].cpu_ticks[CPU_STATE_USER]
                   + (ULONG_MAX - prev_cpu_load[i].cpu_ticks[CPU_STATE_USER]
                      + 1);
        }
 
        if (cpu_load[i].cpu_ticks[CPU_STATE_NICE] >=
            prev_cpu_load[i].cpu_ticks[CPU_STATE_NICE])
        {
          t_nice = cpu_load[i].cpu_ticks[CPU_STATE_NICE]
                   - prev_cpu_load[i].cpu_ticks[CPU_STATE_NICE];
        }
        else
        {
          t_nice = cpu_load[i].cpu_ticks[CPU_STATE_NICE]
                   + (ULONG_MAX - prev_cpu_load[i].cpu_ticks[CPU_STATE_NICE]
                      + 1);
        }
 
        if (cpu_load[i].cpu_ticks[CPU_STATE_IDLE] >=
            prev_cpu_load[i].cpu_ticks[CPU_STATE_IDLE])
        {
          t_idle = cpu_load[i].cpu_ticks[CPU_STATE_IDLE]
                   - prev_cpu_load[i].cpu_ticks[CPU_STATE_IDLE];
        }
        else
        {
          t_idle = cpu_load[i].cpu_ticks[CPU_STATE_IDLE]
                   + (ULONG_MAX - prev_cpu_load[i].cpu_ticks[CPU_STATE_IDLE]
                      + 1);
        }
        t_total = t_sys + t_user + t_nice + t_idle;
        t_idle_all += t_idle;
        t_total_all += t_total;
      }
      for (i = 0; i < cpu_count; i++)
      {
        for (j = 0; j < CPU_STATE_MAX; j++)
        {
          prev_cpu_load[i].cpu_ticks[j] = cpu_load[i].cpu_ticks[j];
        }
      }
      if (t_total_all > 0)
        currentCPULoad = 100 - (100 * t_idle_all) / t_total_all;
      else
        currentCPULoad = -1;
      vm_deallocate (mach_task_self (),
                     (vm_address_t) cpu_load,
                     (vm_size_t) (cpu_msg_count * sizeof(*cpu_load)));
      currentIOLoad = -1;       /* FIXME-OSX! */
      return GNUNET_OK;
    }
    else
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "host_processor_info failed.");
      return GNUNET_SYSERR;
    }
  }
#endif
  /* try kstat (Solaris only) */
#if SOLARIS && HAVE_KSTAT_H && HAVE_SYS_SYSINFO_H
  {
    static long long last_idlecount;
    static long long last_totalcount;
    static int kstat_once;      /* if open fails, don't keep
                                   trying */
    kstat_ctl_t *kc;
    kstat_t *khelper;
    long long idlecount;
    long long totalcount;
    long long deltaidle;
    long long deltatotal;
 
    if (kstat_once == 1)
      goto ABORT_KSTAT;
    kc = kstat_open ();
    if (kc == NULL)
    {
      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kstat_close");
      goto ABORT_KSTAT;
    }
 
    idlecount = 0;
    totalcount = 0;
    for (khelper = kc->kc_chain; khelper != NULL; khelper = khelper->ks_next)
    {
      cpu_stat_t stats;
 
      if (0 != strncmp (khelper->ks_name, "cpu_stat", strlen ("cpu_stat")))
        continue;
      if (khelper->ks_data_size > sizeof(cpu_stat_t))
        continue;               /* better save then sorry! */
      if (-1 != kstat_read (kc, khelper, &stats))
      {
        idlecount += stats.cpu_sysinfo.cpu[CPU_IDLE];
        totalcount
          += stats.cpu_sysinfo.cpu[CPU_IDLE]
             + stats.cpu_sysinfo.cpu[CPU_USER]
             + stats.cpu_sysinfo.cpu[CPU_KERNEL]
             + stats.cpu_sysinfo.cpu[CPU_WAIT];
      }
    }
    if (0 != kstat_close (kc))
      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kstat_close");
    if ((idlecount == 0) && (totalcount == 0))
      goto ABORT_KSTAT;         /* no stats found => abort */
    deltaidle = idlecount - last_idlecount;
    deltatotal = totalcount - last_totalcount;
    if ((deltatotal > 0) && (last_totalcount > 0))
    {
      currentCPULoad = (unsigned int) (100.0 * deltaidle / deltatotal);
      if (currentCPULoad > 100)
        currentCPULoad = 100;   /* odd */
      if (currentCPULoad < 0)
        currentCPULoad = 0;     /* odd */
      currentCPULoad = 100 - currentCPULoad;    /* computed idle-load before! */
    }
    else
      currentCPULoad = -1;
    currentIOLoad = -1;         /* FIXME-SOLARIS! */
    last_idlecount = idlecount;
    last_totalcount = totalcount;
    return GNUNET_OK;
ABORT_KSTAT:
    kstat_once = 1;             /* failed, don't try again */
    return GNUNET_SYSERR;
  }
#endif
 
  /* insert methods better than getloadavg for
     other platforms HERE! */
 
  /* ok, maybe we have getloadavg on this platform */
#if HAVE_GETLOADAVG
  {
    static int warnOnce = 0;
    double loadavg;
    if (1 != getloadavg (&loadavg, 1))
    {
      /* only warn once, if there is a problem with
         getloadavg, we're going to hit it frequently... */
      if (warnOnce == 0)
      {
        warnOnce = 1;
        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "getloadavg");
      }
      return GNUNET_SYSERR;
    }
    else
    {
      /* success with getloadavg */
      currentCPULoad = (int) (100 * loadavg);
      currentIOLoad = -1;       /* FIXME */
      return GNUNET_OK;
    }
  }
#endif
 
  /* loadaverage not defined and no platform
     specific alternative defined
     => default: error
   */
  return GNUNET_SYSERR;
}

References currentCPULoad, currentIOLoad, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_log_strerror, GNUNET_log_strerror_file, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, idle(), consensus-simulation::int, line, ret, and stats.

Referenced by GST_stats_init(), and updateAgedLoad().

Here is the call graph for this function:

Here is the caller graph for this function:

updateAgedLoad()

static void updateAgedLoad ( )

static

Update load values (if enough time has expired), including computation of averages.

Code assumes that lock has already been obtained.

Definition at line 417 of file gnunet-service-testbed_cpustatus.c.

{
  static struct GNUNET_TIME_Absolute lastCall;
  struct GNUNET_TIME_Relative age;
 
  age = GNUNET_TIME_absolute_get_duration (lastCall);
  if ((agedCPULoad == -1)
      || (age.rel_value_us > 500000))
  {
    /* use smoothing, but do NOT update lastRet at frequencies higher
       than 500ms; this makes the smoothing (mostly) independent from
       the frequency at which getCPULoad is called (and we don't spend
       more time measuring CPU than actually computing something). */
    lastCall = GNUNET_TIME_absolute_get ();
    updateUsage ();
    if (currentCPULoad == -1)
    {
      agedCPULoad = -1;
    }
    else
    {
      if (agedCPULoad == -1)
      {
        agedCPULoad = currentCPULoad;
      }
      else
      {
        /* for CPU, we don't do the 'fast increase' since CPU is much
           more jitterish to begin with */
        agedCPULoad = (agedCPULoad * 31 + currentCPULoad) / 32;
      }
    }
    if (currentIOLoad == -1)
    {
      agedIOLoad = -1;
    }
    else
    {
      if (agedIOLoad == -1)
      {
        agedIOLoad = currentIOLoad;
      }
      else
      {
        /* for IO, we don't do the 'fast increase' since IO is much
           more jitterish to begin with */
        agedIOLoad = (agedIOLoad * 31 + currentIOLoad) / 32;
      }
    }
  }
}

References agedCPULoad, agedIOLoad, currentCPULoad, currentIOLoad, GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_Relative::rel_value_us, and updateUsage().

Referenced by cpu_get_load(), and disk_get_load().

Here is the call graph for this function:

Here is the caller graph for this function:

cpu_get_load()

static int cpu_get_load ( )

static

Get the load of the CPU relative to what is allowed.

Returns

the CPU load as a percentage of allowed (100 is equivalent to full load)

Definition at line 476 of file gnunet-service-testbed_cpustatus.c.

{
  updateAgedLoad ();
  return (int) agedCPULoad;
}

References agedCPULoad, and updateAgedLoad().

Referenced by sample_load_task().

Here is the call graph for this function:

Here is the caller graph for this function:

disk_get_load()

static int disk_get_load ( )

static

Get the load of the CPU relative to what is allowed.

Returns

the CPU load as a percentage of allowed (100 is equivalent to full load)

Definition at line 489 of file gnunet-service-testbed_cpustatus.c.

{
  updateAgedLoad ();
  return (int) agedIOLoad;
}

References agedIOLoad, and updateAgedLoad().

Referenced by sample_load_task().

Here is the call graph for this function:

Here is the caller graph for this function:

mem_get_usage()

static unsigned int mem_get_usage ( )

static

Get the percentage of memory used.

Returns

the percentage of memory used

Definition at line 502 of file gnunet-service-testbed_cpustatus.c.

{
  double percentage;
 
  meminfo ();
  percentage = (((double) kb_main_used) / ((double) kb_main_total) * 100.0);
  return (unsigned int) percentage;
}

References kb_main_total, kb_main_used, and meminfo().

Referenced by sample_load_task().

Here is the call graph for this function:

Here is the caller graph for this function:

sample_load_task()

static void sample_load_task ( void *  cls )

static

Definition at line 544 of file gnunet-service-testbed_cpustatus.c.

{
  struct GNUNET_TIME_Absolute now;
  char *str;
  int nbs;
  int ld_cpu;
  int ld_disk;
  unsigned int mem_usage;
  unsigned int nproc;
 
  sample_load_task_id = NULL;
  ld_cpu = cpu_get_load ();
  ld_disk = disk_get_load ();
  if ((-1 == ld_cpu) || (-1 == ld_disk))
    goto reschedule;
  mem_usage = mem_get_usage ();
#ifdef __linux__
  nproc = get_nproc ();
#else
  nproc = 0;
#endif
  now = GNUNET_TIME_absolute_get ();
  nbs = GNUNET_asprintf (&str, "%llu %d %d %u %u\n", now.abs_value_us / 1000LL
                         / 1000LL,
                         ld_cpu, ld_disk, mem_usage, nproc);
  if (0 < nbs)
  {
    GNUNET_BIO_write (bw, "sample load task", str, nbs);
  }
  else
    GNUNET_break (0);
  GNUNET_free (str);
 
reschedule:
  sample_load_task_id =
    GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
                                  &sample_load_task, NULL);
}

References GNUNET_TIME_Absolute::abs_value_us, bw, cpu_get_load(), disk_get_load(), GNUNET_asprintf(), GNUNET_BIO_write(), GNUNET_break, GNUNET_free, GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_absolute_get(), GNUNET_TIME_UNIT_SECONDS, mem_get_usage(), and sample_load_task_id.

Referenced by GST_stats_init().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_stats_init()

void GST_stats_init

(

const struct GNUNET_CONFIGURATION_Handle *

cfg

)

Initialize logging CPU and IO statisticfs.

Checks the configuration for "STATS_DIR" and logs to a file in that directory. The file is name is generated from the hostname and the process's PID.

Definition at line 590 of file gnunet-service-testbed_cpustatus.c.

{
  char *hostname;
  char *stats_dir;
  char *fn;
  size_t len;
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (cfg, "testbed",
                                               "STATS_DIR", &stats_dir))
    return;
  len = GNUNET_OS_get_hostname_max_length ();
  hostname = GNUNET_malloc (len);
  if (0 != gethostname (hostname, len))
  {
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "gethostname");
    GNUNET_free (stats_dir);
    GNUNET_free (hostname);
    return;
  }
  fn = NULL;
  (void) GNUNET_asprintf (&fn, "%s/%.*s-%jd.dat", stats_dir, (int)len,
                          hostname, (intmax_t) getpid ());
  GNUNET_free (stats_dir);
  GNUNET_free (hostname);
  if (NULL == (bw = GNUNET_BIO_write_open_file (fn)))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("Cannot open %s for writing load statistics.  "
                   "Not logging load statistics\n"), fn);
    GNUNET_free (fn);
    return;
  }
  GNUNET_free (fn);
  sample_load_task_id = GNUNET_SCHEDULER_add_now (&sample_load_task, NULL);
#ifdef __linux__
  proc_stat = fopen ("/proc/stat", "r");
  if (NULL == proc_stat)
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
                              "fopen", "/proc/stat");
#elif OSX
  initMachCpuStats ();
#endif
  updateUsage ();                /* initialize */
}

References _, bw, cfg, GNUNET_asprintf(), GNUNET_BIO_write_open_file(), GNUNET_CONFIGURATION_get_value_filename(), GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_log_strerror, GNUNET_log_strerror_file, GNUNET_malloc, GNUNET_OK, GNUNET_OS_get_hostname_max_length, GNUNET_SCHEDULER_add_now(), hostname, len, sample_load_task(), sample_load_task_id, and updateUsage().

Referenced by testbed_run().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_stats_destroy()

void GST_stats_destroy

(

void

)

Shutdown the status calls module.

Definition at line 641 of file gnunet-service-testbed_cpustatus.c.

{
  if (NULL == bw)
    return;
#ifdef __linux__
  if (proc_stat != NULL)
  {
    fclose (proc_stat);
    proc_stat = NULL;
  }
#elif OSX
  GNUNET_free (prev_cpu_load);
#endif
  if (NULL != sample_load_task_id)
  {
    GNUNET_SCHEDULER_cancel (sample_load_task_id);
    sample_load_task_id = NULL;
  }
  GNUNET_break (GNUNET_OK == GNUNET_BIO_write_close (bw, NULL));
  bw = NULL;
}

References bw, GNUNET_BIO_write_close(), GNUNET_break, GNUNET_free, GNUNET_OK, GNUNET_SCHEDULER_cancel(), and sample_load_task_id.

Referenced by shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

currentCPULoad

int currentCPULoad

static

Current CPU load, as percentage of CPU cycles not idle or blocked on IO.

Definition at line 68 of file gnunet-service-testbed_cpustatus.c.

Referenced by updateAgedLoad(), and updateUsage().

agedCPULoad

double agedCPULoad = -1

static

Definition at line 70 of file gnunet-service-testbed_cpustatus.c.

Referenced by cpu_get_load(), and updateAgedLoad().

currentIOLoad

int currentIOLoad

static

Current IO load, as percentage of CPU cycles blocked on IO.

Definition at line 75 of file gnunet-service-testbed_cpustatus.c.

Referenced by updateAgedLoad(), and updateUsage().

agedIOLoad

double agedIOLoad = -1

static

Definition at line 77 of file gnunet-service-testbed_cpustatus.c.

Referenced by disk_get_load(), and updateAgedLoad().

bw

struct GNUNET_BIO_WriteHandle* bw

handle to the file to write the load statistics to

Definition at line 83 of file gnunet-service-testbed_cpustatus.c.

Referenced by call_flush_completion(), GNUNET_TRANSPORT_application_suggest(), GST_stats_destroy(), GST_stats_init(), and sample_load_task().

sample_load_task_id

struct GNUNET_SCHEDULER_Task* sample_load_task_id

Definition at line 85 of file gnunet-service-testbed_cpustatus.c.

Referenced by GST_stats_destroy(), GST_stats_init(), and sample_load_task().