src/mic.c

   1 /**
   2  * collectd - src/mic.c
   3  * Copyright (C) 2013 Battelle Memorial Institute
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License as published by the
   7  * Free Software Foundation; only version 2 of the License is applicable.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  17  *
  18  * Authors:
  19  *   Evan Felix <evan.felix at pnnl.gov>
  20  **/
  21
  22 #include "collectd.h"
  23
  24 #include "plugin.h"
  25 #include "common.h"
  26 #include "utils_ignorelist.h"
  27
  28 #include <MicAccessTypes.h>
  29 #include <MicAccessErrorTypes.h>
  30 #include <MicAccessApi.h>
  31 #include <MicThermalAPI.h>
  32 #include <MicPowerManagerAPI.h>
  33
  34 #define MAX_MICS 32
  35 #define MAX_CORES 256
  36
  37 static MicDeviceOnSystem mics[MAX_MICS];
  38 static U32 num_mics = 0;
  39 static HANDLE mic_handle = NULL;
  40
  41 static int const therm_ids[] = {
  42         eMicThermalDie, eMicThermalDevMem, eMicThermalFin, eMicThermalFout,
  43         eMicThermalVccp, eMicThermalVddg, eMicThermalVddq };
  44 static char const * const therm_names[] = {
  45         "die", "devmem", "fin", "fout",
  46         "vccp", "vddg", "vddq" };
  47
  48 static const char *config_keys[] =
  49 {
  50         "ShowCPU",
  51         "ShowCPUCores",
  52         "ShowMemory",
  53         "ShowTemperatures",
  54         "Temperature",
  55         "IgnoreSelectedTemperature",
  56         "ShowPower",
  57         "Power",
  58         "IgnoreSelectedPower"
  59 };
  60 static int config_keys_num = STATIC_ARRAY_SIZE (config_keys);
  61
  62 static _Bool show_cpu = 1;
  63 static _Bool show_cpu_cores = 1;
  64 static _Bool show_memory = 1;
  65 static _Bool show_temps = 1;
  66 static ignorelist_t *temp_ignore = NULL;
  67 static _Bool show_power = 1;
  68 static ignorelist_t *power_ignore = NULL;
  69
  70 static int mic_init (void)
  71 {
  72         U32 ret;
  73         U32 mic_count;
  74
  75         if (mic_handle)
  76                 return (0);
  77
  78         mic_count = (U32) STATIC_ARRAY_SIZE(mics);
  79         ret = MicInitAPI(&mic_handle,  eTARGET_SCIF_DRIVER, mics, &mic_count);
  80         if (ret != MIC_ACCESS_API_SUCCESS) {
  81                 ERROR("mic plugin: Problem initializing MicAccessAPI: %s",
  82                                 MicGetErrorString(ret));
  83         }
  84         DEBUG("mic plugin: found: %"PRIu32" MIC(s)",mic_count);
  85
  86         if (mic_count<0 || mic_count>=MAX_MICS) {
  87                 ERROR("mic plugin: No Intel MICs in system");
  88                 return (1);
  89         }
  90         else {
  91                 num_mics = mic_count;
  92                 return (0);
  93         }
  94 }
  95
  96 static int mic_config (const char *key, const char *value) {
  97         if (temp_ignore == NULL)
  98                 temp_ignore = ignorelist_create(1);
  99         if (power_ignore == NULL)
 100                 power_ignore = ignorelist_create(1);
 101         if (temp_ignore == NULL || power_ignore == NULL)
 102                 return (1);
 103
 104         if (strcasecmp("ShowCPU",key) == 0)
 105         {
 106                 show_cpu = IS_TRUE(value);
 107         }
 108         else if (strcasecmp("ShowCPUCores",key) == 0)
 109         {
 110                 show_cpu_cores = IS_TRUE(value);
 111         }
 112         else if (strcasecmp("ShowTemperatures",key) == 0)
 113         {
 114                 show_temps = IS_TRUE(value);
 115         }
 116         else if (strcasecmp("ShowMemory",key) == 0)
 117         {
 118                 show_memory = IS_TRUE(value);
 119         }
 120         else if (strcasecmp("ShowPower",key) == 0)
 121         {
 122                 show_power = IS_TRUE(value);
 123         }
 124         else if (strcasecmp("Temperature",key) == 0)
 125         {
 126                 ignorelist_add(temp_ignore,value);
 127         }
 128         else if (strcasecmp("IgnoreSelectedTemperature",key) == 0)
 129         {
 130                 int invert = 1;
 131                 if (IS_TRUE(value))
 132                         invert = 0;
 133                 ignorelist_set_invert(temp_ignore,invert);
 134         }
 135         else if (strcasecmp("Power",key) == 0)
 136         {
 137                 ignorelist_add(power_ignore,value);
 138         }
 139         else if (strcasecmp("IgnoreSelectedPower",key) == 0)
 140         {
 141                 int invert = 1;
 142                 if (IS_TRUE(value))
 143                         invert = 0;
 144                 ignorelist_set_invert(power_ignore,invert);
 145         }
 146         else
 147         {
 148                 return (-1);
 149         }
 150         return (0);
 151 }
 152
 153 static void mic_submit_memory_use(int micnumber, const char *type_instance, U32 val)
 154 {
 155         value_t values[1];
 156         value_list_t vl = VALUE_LIST_INIT;
 157
 158         /* MicAccessAPI reports KB's of memory, adjust for this */
 159         DEBUG("mic plugin: Memory Value Report; %u %lf",val,((gauge_t)val)*1024.0);
 160         values[0].gauge = ((gauge_t)val)*1024.0;
 161
 162         vl.values=values;
 163         vl.values_len=1;
 164
 165         strncpy (vl.host, hostname_g, sizeof (vl.host));
 166         strncpy (vl.plugin, "mic", sizeof (vl.plugin));
 167         ssnprintf (vl.plugin_instance, sizeof (vl.plugin_instance), "%i", micnumber);
 168         strncpy (vl.type, "memory", sizeof (vl.type));
 169         strncpy (vl.type_instance, type_instance, sizeof (vl.type_instance));
 170
 171         plugin_dispatch_values (&vl);
 172 }
 173
 174 /* Gather memory Utilization */
 175 static int mic_read_memory(int mic)
 176 {
 177         U32 ret;
 178         U32 mem_total,mem_free,mem_bufs;
 179
 180         ret = MicGetMemoryUtilization(mic_handle,&mem_total,&mem_free,&mem_bufs);
 181         if (ret != MIC_ACCESS_API_SUCCESS) {
 182                 ERROR("mic plugin: Problem getting Memory Utilization: %s",
 183                                 MicGetErrorString(ret));
 184                 return (1);
 185         }
 186         mic_submit_memory_use(mic,"free",mem_free);
 187         mic_submit_memory_use(mic,"used",mem_total-mem_free-mem_bufs);
 188         mic_submit_memory_use(mic,"buffered",mem_bufs);
 189         DEBUG("mic plugin: Memory Read: %u %u %u",mem_total,mem_free,mem_bufs);
 190         return (0);
 191 }
 192
 193 static void mic_submit_temp(int micnumber, const char *type, gauge_t val)
 194 {
 195         value_t values[1];
 196         value_list_t vl = VALUE_LIST_INIT;
 197
 198         values[0].gauge = val;
 199
 200         vl.values=values;
 201         vl.values_len=1;
 202
 203         strncpy (vl.host, hostname_g, sizeof (vl.host));
 204         strncpy (vl.plugin, "mic", sizeof (vl.plugin));
 205         ssnprintf (vl.plugin_instance, sizeof (vl.plugin_instance),
 206                         "%i", micnumber);
 207         strncpy (vl.type, "temperature", sizeof (vl.type));
 208         strncpy (vl.type_instance, type, sizeof (vl.type_instance));
 209
 210         plugin_dispatch_values (&vl);
 211 }
 212
 213 /* Gather Temperature Information */
 214 static int mic_read_temps(int mic)
 215 {
 216         size_t num_therms = STATIC_ARRAY_SIZE(therm_ids);
 217         size_t j;
 218
 219         for (j = 0; j < num_therms; j++) {
 220                 U32 status;
 221                 U32 temp_buffer;
 222                 U32 buffer_size = (U32)sizeof(temp_buffer);
 223                 char const *name = therm_names[j];
 224
 225                 if (ignorelist_match(temp_ignore, name) != 0)
 226                         continue;
 227
 228                 status = MicGetTemperature(mic_handle, therm_ids[j],
 229                                 &temp_buffer, &buffer_size);
 230                 if (status != MIC_ACCESS_API_SUCCESS) {
 231                         ERROR("mic plugin: Error reading temperature \"%s\": "
 232                                         "%s", name, MicGetErrorString(status));
 233                         return (1);
 234                 }
 235                 mic_submit_temp(mic, name, temp_buffer);
 236         }
 237         return (0);
 238 }
 239
 240 static void mic_submit_cpu(int micnumber, const char *type_instance,
 241                 int core, derive_t val)
 242 {
 243         value_t values[1];
 244         value_list_t vl = VALUE_LIST_INIT;
 245
 246         values[0].derive = val;
 247
 248         vl.values=values;
 249         vl.values_len=1;
 250
 251         strncpy (vl.host, hostname_g, sizeof (vl.host));
 252         strncpy (vl.plugin, "mic", sizeof (vl.plugin));
 253         if (core < 0) /* global aggregation */
 254                 ssnprintf (vl.plugin_instance, sizeof (vl.plugin_instance),
 255                                 "%i", micnumber);
 256         else /* per-core statistics */
 257                 ssnprintf (vl.plugin_instance, sizeof (vl.plugin_instance),
 258                                 "%i-cpu-%i", micnumber, core);
 259         strncpy (vl.type, "cpu", sizeof (vl.type));
 260         strncpy (vl.type_instance, type_instance, sizeof (vl.type_instance));
 261
 262         plugin_dispatch_values (&vl);
 263 }
 264
 265 /*Gather CPU Utilization Information */
 266 static int mic_read_cpu(int mic)
 267 {
 268         MicCoreUtil core_util;
 269         MicCoreJiff core_jiffs[MAX_CORES];
 270         U32 core_jiffs_size;
 271         U32 status;
 272
 273         core_jiffs_size = MAX_CORES * sizeof(MicCoreJiff);
 274         status = MicGetCoreUtilization(mic_handle, &core_util,
 275                         core_jiffs, &core_jiffs_size);
 276         if (status != MIC_ACCESS_API_SUCCESS) {
 277                 ERROR("mic plugin: Problem getting CPU utilization: %s",
 278                                 MicGetErrorString(status));
 279                 return(-1);
 280         }
 281
 282         if (show_cpu) {
 283                 mic_submit_cpu(mic, "user", -1, core_util.sum.user);
 284                 mic_submit_cpu(mic, "sys", -1, core_util.sum.sys);
 285                 mic_submit_cpu(mic, "nice", -1, core_util.sum.nice);
 286                 mic_submit_cpu(mic, "idle", -1, core_util.sum.idle);
 287         }
 288
 289         if (show_cpu_cores) {
 290                 int j;
 291                 for (j = 0; j < core_util.core; j++) {
 292                         mic_submit_cpu(mic, "user", j, core_jiffs[j].user);
 293                         mic_submit_cpu(mic, "sys", j, core_jiffs[j].sys);
 294                         mic_submit_cpu(mic, "nice", j, core_jiffs[j].nice);
 295                         mic_submit_cpu(mic, "idle", j, core_jiffs[j].idle);
 296                 }
 297         }
 298         return (0);
 299 }
 300
 301 static void mic_submit_power(int micnumber, const char *type, const char *type_instance, gauge_t val)
 302 {
 303         value_t values[1];
 304         value_list_t vl = VALUE_LIST_INIT;
 305
 306         values[0].gauge = val;
 307
 308         vl.values=values;
 309         vl.values_len=1;
 310
 311         strncpy (vl.host, hostname_g, sizeof (vl.host));
 312         strncpy (vl.plugin, "mic", sizeof (vl.plugin));
 313         ssnprintf (vl.plugin_instance, sizeof (vl.plugin_instance), "%i", micnumber);
 314         strncpy (vl.type, type, sizeof (vl.type));
 315         strncpy (vl.type_instance, type_instance, sizeof (vl.type_instance));
 316
 317         plugin_dispatch_values (&vl);
 318 }
 319
 320 /* Gather Power Information */
 321 static int mic_read_power(int mic)
 322 {
 323         U32 ret;
 324         MicPwrUsage power_use;
 325
 326         ret = MicGetPowerUsage(mic_handle,&power_use);
 327         if (ret != MIC_ACCESS_API_SUCCESS) {
 328                 ERROR("mic plugin: Problem getting Power Usage: %s",
 329                         MicGetErrorString(ret));
 330                 return (1);
 331         }
 332
 333         /* power is in uWatts, current in mA, voltage in uVolts..   convert to
 334          * base unit */
 335         #define SUB_POWER(name) do { if (ignorelist_match(power_ignore,#name)==0) \
 336                 mic_submit_power(mic,"power",#name,(gauge_t)power_use.name.prr*0.000001); \
 337         } while(0)
 338         #define SUB_VOLTS(name) do { if (ignorelist_match(power_ignore,#name)==0) {\
 339                 mic_submit_power(mic,"power",#name,(gauge_t)(power_use.name.pwr*0.000001)); \
 340                 mic_submit_power(mic,"current",#name,(gauge_t)(power_use.name.cur*0.001)); \
 341                 mic_submit_power(mic,"voltage",#name,(gauge_t)(power_use.name.volt*0.000001)); \
 342         }} while(0)
 343
 344         SUB_POWER(total0);
 345         SUB_POWER(total1);
 346         SUB_POWER(inst);
 347         SUB_POWER(imax);
 348         SUB_POWER(pcie);
 349         SUB_POWER(c2x3);
 350         SUB_POWER(c2x4);
 351         SUB_VOLTS(vccp);
 352         SUB_VOLTS(vddg);
 353         SUB_VOLTS(vddq);
 354
 355         return (0);
 356 }
 357
 358 static int mic_read (void)
 359 {
 360         int i;
 361         U32 ret;
 362         int error;
 363
 364         error=0;
 365         for (i=0;i<num_mics;i++) {
 366                 ret = MicInitAdapter(&mic_handle,&mics[i]);
 367                 if (ret != MIC_ACCESS_API_SUCCESS) {
 368                         ERROR("mic plugin: Problem initializing MicAdapter: %s",
 369                                         MicGetErrorString(ret));
 370                         error=1;
 371                 }
 372
 373                 if (error == 0 && show_memory)
 374                         error = mic_read_memory(i);
 375
 376                 if (error == 0 && show_temps)
 377                         error = mic_read_temps(i);
 378
 379                 if (error == 0 && (show_cpu || show_cpu_cores))
 380                         error = mic_read_cpu(i);
 381
 382                 if (error == 0 && (show_power))
 383                         error = mic_read_power(i);
 384
 385                 ret = MicCloseAdapter(mic_handle);
 386                 if (ret != MIC_ACCESS_API_SUCCESS) {
 387                         ERROR("mic plugin: Problem closing MicAdapter: %s",
 388                                         MicGetErrorString(ret));
 389                         error=2;
 390                         break;
 391                 }
 392         }
 393         if (num_mics==0)
 394                 error=3;
 395         return error;
 396 }
 397
 398
 399 static int mic_shutdown (void)
 400 {
 401         if (mic_handle)
 402                 MicCloseAPI(&mic_handle);
 403         mic_handle = NULL;
 404
 405         return (0);
 406 }
 407
 408 void module_register (void)
 409 {
 410         plugin_register_init ("mic", mic_init);
 411         plugin_register_shutdown ("mic", mic_shutdown);
 412         plugin_register_read ("mic", mic_read);
 413         plugin_register_config ("mic",mic_config, config_keys, config_keys_num);
 414 } /* void module_register */
 415
 416 /*
 417  * vim: set shiftwidth=8 softtabstop=8 noet textwidth=78 :
 418  */