winsup/cygwin/loadavg.cc

   1 /* loadavg.cc: load average support.
   2
   3   This file is part of Cygwin.
   4
   5   This software is a copyrighted work licensed under the terms of the
   6   Cygwin license.  Please consult the file "CYGWIN_LICENSE" for
   7   details. */
   8
   9 /*
  10   Emulate load average
  11
  12   There's a fair amount of approximation done here, so don't try to use this to
  13   actually measure anything, but it should be good enough for programs to
  14   throttle their activity based on load.
  15
  16   A global load average estimate is maintained in shared memory.  Access to that
  17   is guarded by a mutex.  This estimate is only updated at most every 5 seconds.
  18
  19   We attempt to count running and runnable processes, but unlike linux we don't
  20   count processes in uninterruptible sleep (blocked on I/O).
  21
  22   The number of running processes is estimated as (NumberOfProcessors) * (%
  23   Processor Time).  The number of runnable processes is estimated as
  24   ProcessorQueueLength.
  25
  26   Note that PDH will only return data for '% Processor Time' afer the second
  27   call to PdhCollectQueryData(), as it's computed over an interval, so the first
  28   attempt to estimate load will fail and 0.0 will be returned.
  29
  30   We also assume that '% Processor Time' averaged over the interval since the
  31   last time getloadavg() was called is a good approximation of the instantaneous
  32   '% Processor Time'.
  33 */
  34
  35 #include "winsup.h"
  36 #include "shared_info.h"
  37 #include "loadavg.h"
  38
  39 #include <math.h>
  40 #include <time.h>
  41 #include <sys/strace.h>
  42 #include <pdh.h>
  43
  44 static PDH_HQUERY query;
  45 static PDH_HCOUNTER counter1;
  46 static PDH_HCOUNTER counter2;
  47 static HANDLE mutex;
  48
  49 static bool load_init (void)
  50 {
  51   static NO_COPY bool tried = false;
  52   static NO_COPY bool initialized = false;
  53
  54   if (!tried) {
  55     tried = true;
  56
  57     PDH_STATUS status;
  58
  59     status = PdhOpenQueryW (NULL, 0, &query);
  60     if (status != STATUS_SUCCESS)
  61       {
  62         debug_printf ("PdhOpenQueryW, status %y", status);
  63         return false;
  64       }
  65     status = PdhAddEnglishCounterW (query,
  66                                     L"\\Processor(_Total)\\% Processor Time",
  67                                     0, &counter1);
  68     if (status != STATUS_SUCCESS)
  69       {
  70         debug_printf ("PdhAddEnglishCounterW(time), status %y", status);
  71         return false;
  72       }
  73     status = PdhAddEnglishCounterW (query,
  74                                     L"\\System\\Processor Queue Length",
  75                                     0, &counter2);
  76
  77     if (status != STATUS_SUCCESS)
  78       {
  79         debug_printf ("PdhAddEnglishCounterW(queue length), status %y", status);
  80         return false;
  81       }
  82
  83     mutex = CreateMutex(&sec_all_nih, FALSE, "cyg.loadavg.mutex");
  84     if (!mutex) {
  85       debug_printf("opening loadavg mutexfailed\n");
  86       return false;
  87     }
  88
  89     initialized = true;
  90   }
  91
  92   return initialized;
  93 }
  94
  95 /* estimate the current load */
  96 static bool get_load (double *load)
  97 {
  98   *load = 0.0;
  99
 100   PDH_STATUS ret = PdhCollectQueryData (query);
 101   if (ret != ERROR_SUCCESS)
 102     return false;
 103
 104   /* Estimate the number of running processes as (NumberOfProcessors) * (%
 105      Processor Time) */
 106   PDH_FMT_COUNTERVALUE fmtvalue1;
 107   ret = PdhGetFormattedCounterValue (counter1, PDH_FMT_DOUBLE, NULL, &fmtvalue1);
 108   if (ret != ERROR_SUCCESS)
 109     return false;
 110
 111   double running = fmtvalue1.doubleValue * wincap.cpu_count () / 100;
 112
 113   /* Estimate the number of runnable processes using ProcessorQueueLength */
 114   PDH_FMT_COUNTERVALUE fmtvalue2;
 115   ret = PdhGetFormattedCounterValue (counter2, PDH_FMT_LONG, NULL, &fmtvalue2);
 116   if (ret != ERROR_SUCCESS)
 117     return false;
 118
 119   LONG rql = fmtvalue2.longValue;
 120
 121   *load = rql + running;
 122   return true;
 123 }
 124
 125 /*
 126   loadavginfo shared-memory object
 127 */
 128
 129 void loadavginfo::initialize ()
 130 {
 131   for (int i = 0; i < 3; i++)
 132     loadavg[i] = 0.0;
 133
 134   last_time = 0;
 135 }
 136
 137 void loadavginfo::calc_load (int index, int delta_time, int decay_time, double n)
 138 {
 139   double df = 1.0 / exp ((double)delta_time/decay_time);
 140   loadavg[index] = (loadavg[index] * df) + (n * (1.0 - df));
 141 }
 142
 143 void loadavginfo::update_loadavg ()
 144 {
 145   double active_tasks;
 146
 147   if (!get_load (&active_tasks))
 148     return;
 149
 150   /* Don't recalculate the load average if less than 5 seconds has elapsed since
 151      the last time it was calculated */
 152   time_t curr_time = time (NULL);
 153   int delta_time = curr_time - last_time;
 154   if (delta_time < 5) {
 155     return;
 156   }
 157
 158   if (last_time == 0) {
 159     /* Initialize the load average to the current load */
 160     for (int i = 0; i < 3; i++) {
 161       loadavg[i] = active_tasks;
 162     }
 163   } else {
 164     /* Compute the exponentially weighted moving average over ... */
 165     calc_load (0, delta_time, 60,  active_tasks); /* ... 1 min */
 166     calc_load (1, delta_time, 300, active_tasks); /* ... 5 min */
 167     calc_load (2, delta_time, 900, active_tasks); /* ... 15 min */
 168   }
 169
 170   last_time = curr_time;
 171 }
 172
 173 int loadavginfo::fetch (double _loadavg[], int nelem)
 174 {
 175   if (!load_init ())
 176     return 0;
 177
 178   WaitForSingleObject(mutex, INFINITE);
 179
 180   update_loadavg ();
 181
 182   memcpy (_loadavg, loadavg, nelem * sizeof(double));
 183
 184   ReleaseMutex(mutex);
 185
 186   return nelem;
 187 }
 188
 189 /* getloadavg: BSD */
 190 extern "C" int
 191 getloadavg (double loadavg[], int nelem)
 192 {
 193   /* The maximum number of samples is 3 */
 194   if (nelem > 3)
 195     nelem = 3;
 196
 197   /* Return the samples and number of samples retrieved */
 198   return cygwin_shared->loadavg.fetch(loadavg, nelem);
 199 }