granicus.if.org Git - sysstat/blob - pcp_def_metrics.c

   1 /*
   2  * pcp_def_metrics.c: Funtions used by sadf to define PCP metrics
   3  * (C) 2019 by Sebastien GODARD (sysstat <at> orange.fr)
   4  *
   5  ***************************************************************************
   6  * This program is free software; you can redistribute it and/or modify it *
   7  * under the terms of the GNU General Public License as published  by  the *
   8  * Free Software Foundation; either version 2 of the License, or (at  your *
   9  * option) any later version.                                              *
  10  *                                                                         *
  11  * This program is distributed in the hope that it  will  be  useful,  but *
  12  * WITHOUT ANY WARRANTY; without the implied warranty  of  MERCHANTABILITY *
  13  * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License *
  14  * for more details.                                                       *
  15  *                                                                         *
  16  * You should have received a copy of the GNU General Public License along *
  17  * with this program; if not, write to the Free Software Foundation, Inc., *
  18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA              *
  19  ***************************************************************************
  20  */
  21
  22 #include "common.h"
  23 #include "sa.h"
  24
  25 #ifdef HAVE_PCP
  26 #include <pcp/pmapi.h>
  27 #include <pcp/import.h>
  28 #endif
  29
  30 /*
  31  ***************************************************************************
  32  * Define PCP metrics for CPU statistics.
  33  *
  34  * IN:
  35  * @a           Activity structure with statistics.
  36  ***************************************************************************
  37  */
  38 void pcp_def_cpu_metrics(struct activity *a)
  39 {
  40 #ifdef HAVE_PCP
  41         int i, first = TRUE;
  42         char buf[64];
  43         pmInDom indom;
  44
  45         for (i = 0; (i < a->nr_ini) && (i < a->bitmap->b_size + 1); i++) {
  46
  47                 /*
  48                  * Should current CPU (including CPU "all") be displayed?
  49                  * NB: Offline not tested (they may be turned off and on within
  50                  * the same file.
  51                  */
  52                 if (!(a->bitmap->b_array[i >> 3] & (1 << (i & 0x07))))
  53                         /* CPU not selected */
  54                         continue;
  55
  56                 if (!i) {
  57                         /* This is CPU "all" */
  58                         pmiAddMetric("kernel.all.cpu.user",
  59                                      PM_IN_NULL, PM_TYPE_FLOAT, PM_INDOM_NULL, PM_SEM_INSTANT,
  60                                      pmiUnits(0, 0, 0, 0, 0, 0));
  61
  62                         pmiAddMetric("kernel.all.cpu.nice",
  63                                      PM_IN_NULL, PM_TYPE_FLOAT, PM_INDOM_NULL, PM_SEM_INSTANT,
  64                                      pmiUnits(0, 0, 0, 0, 0, 0));
  65
  66                         pmiAddMetric("kernel.all.cpu.sys",
  67                                      PM_IN_NULL, PM_TYPE_FLOAT, PM_INDOM_NULL, PM_SEM_INSTANT,
  68                                      pmiUnits(0, 0, 0, 0, 0, 0));
  69
  70                         pmiAddMetric("kernel.all.cpu.idle",
  71                                      PM_IN_NULL, PM_TYPE_FLOAT, PM_INDOM_NULL, PM_SEM_INSTANT,
  72                                      pmiUnits(0, 0, 0, 0, 0, 0));
  73
  74                         pmiAddMetric("kernel.all.cpu.iowait",
  75                                      PM_IN_NULL, PM_TYPE_FLOAT, PM_INDOM_NULL, PM_SEM_INSTANT,
  76                                      pmiUnits(0, 0, 0, 0, 0, 0));
  77
  78                         pmiAddMetric("kernel.all.cpu.steal",
  79                                      PM_IN_NULL, PM_TYPE_FLOAT, PM_INDOM_NULL, PM_SEM_INSTANT,
  80                                      pmiUnits(0, 0, 0, 0, 0, 0));
  81
  82                         pmiAddMetric("kernel.all.cpu.hardirq",
  83                                      PM_IN_NULL, PM_TYPE_FLOAT, PM_INDOM_NULL, PM_SEM_INSTANT,
  84                                      pmiUnits(0, 0, 0, 0, 0, 0));
  85
  86                         pmiAddMetric("kernel.all.cpu.softirq",
  87                                      PM_IN_NULL, PM_TYPE_FLOAT, PM_INDOM_NULL, PM_SEM_INSTANT,
  88                                      pmiUnits(0, 0, 0, 0, 0, 0));
  89
  90                         pmiAddMetric("kernel.all.cpu.guest",
  91                                      PM_IN_NULL, PM_TYPE_FLOAT, PM_INDOM_NULL, PM_SEM_INSTANT,
  92                                      pmiUnits(0, 0, 0, 0, 0, 0));
  93
  94                         pmiAddMetric("kernel.all.cpu.guest_nice",
  95                                      PM_IN_NULL, PM_TYPE_FLOAT, PM_INDOM_NULL, PM_SEM_INSTANT,
  96                                      pmiUnits(0, 0, 0, 0, 0, 0));
  97                 }
  98                 else {
  99                         if (first) {
 100                                 first = FALSE;
 101
 102                                 indom = pmInDom_build(0, 0);
 103                                 pmiAddMetric("kernel.percpu.cpu.user",
 104                                              PM_IN_NULL, PM_TYPE_FLOAT, indom, PM_SEM_INSTANT,
 105                                              pmiUnits(0, 0, 0, 0, 0, 0));
 106
 107                                 pmiAddMetric("kernel.percpu.cpu.nice",
 108                                              PM_IN_NULL, PM_TYPE_FLOAT, indom, PM_SEM_INSTANT,
 109                                              pmiUnits(0, 0, 0, 0, 0, 0));
 110
 111                                 pmiAddMetric("kernel.percpu.cpu.sys",
 112                                              PM_IN_NULL, PM_TYPE_FLOAT, indom, PM_SEM_INSTANT,
 113                                              pmiUnits(0, 0, 0, 0, 0, 0));
 114
 115                                 pmiAddMetric("kernel.percpu.cpu.idle",
 116                                              PM_IN_NULL, PM_TYPE_FLOAT, indom, PM_SEM_INSTANT,
 117                                              pmiUnits(0, 0, 0, 0, 0, 0));
 118
 119                                 pmiAddMetric("kernel.percpu.cpu.iowait",
 120                                              PM_IN_NULL, PM_TYPE_FLOAT, indom, PM_SEM_INSTANT,
 121                                              pmiUnits(0, 0, 0, 0, 0, 0));
 122
 123                                 pmiAddMetric("kernel.percpu.cpu.steal",
 124                                              PM_IN_NULL, PM_TYPE_FLOAT, indom, PM_SEM_INSTANT,
 125                                              pmiUnits(0, 0, 0, 0, 0, 0));
 126
 127                                 pmiAddMetric("kernel.percpu.cpu.hardirq",
 128                                              PM_IN_NULL, PM_TYPE_FLOAT, indom, PM_SEM_INSTANT,
 129                                              pmiUnits(0, 0, 0, 0, 0, 0));
 130
 131                                 pmiAddMetric("kernel.percpu.cpu.softirq",
 132                                              PM_IN_NULL, PM_TYPE_FLOAT, indom, PM_SEM_INSTANT,
 133                                              pmiUnits(0, 0, 0, 0, 0, 0));
 134
 135                                 pmiAddMetric("kernel.percpu.cpu.guest",
 136                                              PM_IN_NULL, PM_TYPE_FLOAT, indom, PM_SEM_INSTANT,
 137                                              pmiUnits(0, 0, 0, 0, 0, 0));
 138
 139                                 pmiAddMetric("kernel.percpu.cpu.guest_nice",
 140                                              PM_IN_NULL, PM_TYPE_FLOAT, indom, PM_SEM_INSTANT,
 141                                              pmiUnits(0, 0, 0, 0, 0, 0));
 142                         }
 143                         sprintf(buf, "cpu%d", i - 1);
 144                         pmiAddInstance(indom, buf, i - 1);
 145                 }
 146         }
 147 #endif /* HAVE_PCP */
 148 }
 149
 150 /*
 151  ***************************************************************************
 152  * Define PCP metrics for task creation and context switch statistics.
 153  ***************************************************************************
 154  */
 155 void pcp_def_pcsw_metrics(void)
 156 {
 157 #ifdef HAVE_PCP
 158         pmiAddMetric("kernel.all.pswitch",
 159                      PM_IN_NULL, PM_TYPE_FLOAT, PM_INDOM_NULL, PM_SEM_INSTANT,
 160                      pmiUnits(0, -1, 1, 0, PM_TIME_SEC, PM_COUNT_ONE));
 161
 162         pmiAddMetric("kernel.all.proc",
 163                      PM_IN_NULL, PM_TYPE_FLOAT, PM_INDOM_NULL, PM_SEM_INSTANT,
 164                      pmiUnits(0, -1, 1, 0, PM_TIME_SEC, PM_COUNT_ONE));
 165 #endif /* HAVE_PCP */
 166 }
 167
 168 /*
 169  ***************************************************************************
 170  * Define PCP metrics for interrupts statistics.
 171  *
 172  * IN:
 173  * @a           Activity structure with statistics.
 174  ***************************************************************************
 175  */
 176 void pcp_def_irq_metrics(struct activity *a)
 177 {
 178 #ifdef HAVE_PCP
 179         if (a->bitmap->b_array[0] & 1) {
 180                 /* Interrupt "sum" */
 181                 pmiAddMetric("kernel.all.intr",
 182                              PM_IN_NULL, PM_TYPE_FLOAT, PM_INDOM_NULL, PM_SEM_INSTANT,
 183                              pmiUnits(0, -1, 1, 0, PM_TIME_SEC, PM_COUNT_ONE));
 184         }
 185 #endif /* HAVE_PCP */
 186 }
 187
 188 /*
 189  ***************************************************************************
 190  * Define PCP metrics for swapping statistics.
 191  ***************************************************************************
 192  */
 193 void pcp_def_swap_metrics(void)
 194 {
 195 #ifdef HAVE_PCP
 196         pmiAddMetric("swap.pagesin",
 197                      PM_IN_NULL, PM_TYPE_FLOAT, PM_INDOM_NULL, PM_SEM_INSTANT,
 198                      pmiUnits(0, -1, 1, 0, PM_TIME_SEC, PM_COUNT_ONE));
 199
 200         pmiAddMetric("swap.pagesout",
 201                      PM_IN_NULL, PM_TYPE_FLOAT, PM_INDOM_NULL, PM_SEM_INSTANT,
 202                      pmiUnits(0, -1, 1, 0, PM_TIME_SEC, PM_COUNT_ONE));
 203 #endif /* HAVE_PCP */
 204 }
 205
 206 /*
 207  ***************************************************************************
 208  * Define PCP metrics for I/O and transfer rate statistics.
 209  ***************************************************************************
 210  */
 211 void pcp_def_io_metrics(void)
 212 {
 213 #ifdef HAVE_PCP
 214         pmiAddMetric("disk.all.total",
 215                      PM_IN_NULL, PM_TYPE_FLOAT, PM_INDOM_NULL, PM_SEM_INSTANT,
 216                      pmiUnits(0, -1, 1, 0, PM_TIME_SEC, PM_COUNT_ONE));
 217
 218         pmiAddMetric("disk.all.read",
 219                      PM_IN_NULL, PM_TYPE_FLOAT, PM_INDOM_NULL, PM_SEM_INSTANT,
 220                      pmiUnits(0, -1, 1, 0, PM_TIME_SEC, PM_COUNT_ONE));
 221
 222         pmiAddMetric("disk.all.write",
 223                      PM_IN_NULL, PM_TYPE_FLOAT, PM_INDOM_NULL, PM_SEM_INSTANT,
 224                      pmiUnits(0, -1, 1, 0, PM_TIME_SEC, PM_COUNT_ONE));
 225
 226         pmiAddMetric("disk.all.discard",
 227                      PM_IN_NULL, PM_TYPE_FLOAT, PM_INDOM_NULL, PM_SEM_INSTANT,
 228                      pmiUnits(0, -1, 1, 0, PM_TIME_SEC, PM_COUNT_ONE));
 229
 230         pmiAddMetric("disk.all.read_bytes",
 231                      PM_IN_NULL, PM_TYPE_FLOAT, PM_INDOM_NULL, PM_SEM_INSTANT,
 232                      pmiUnits(1, -1, 1, PM_SPACE_KBYTE, PM_TIME_SEC, 0));
 233
 234         pmiAddMetric("disk.all.write_bytes",
 235                      PM_IN_NULL, PM_TYPE_FLOAT, PM_INDOM_NULL, PM_SEM_INSTANT,
 236                      pmiUnits(1, -1, 1, PM_SPACE_KBYTE, PM_TIME_SEC, 0));
 237
 238         pmiAddMetric("disk.all.discard_bytes",
 239                      PM_IN_NULL, PM_TYPE_FLOAT, PM_INDOM_NULL, PM_SEM_INSTANT,
 240                      pmiUnits(1, -1, 1, PM_SPACE_KBYTE, PM_TIME_SEC, 0));
 241 #endif /* HAVE_PCP */
 242 }
 243
 244 /*
 245  ***************************************************************************
 246  * Define PCP metrics for memory statistics.
 247  *
 248  * IN:
 249  * @a           Activity structure with statistics.
 250  ***************************************************************************
 251  */
 252 void pcp_def_memory_metrics(struct activity *a)
 253 {
 254 #ifdef HAVE_PCP
 255         if (DISPLAY_MEMORY(a->opt_flags)) {
 256
 257                 pmiAddMetric("mem.util.free",
 258                              PM_IN_NULL, PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 259                              pmiUnits(1, 0, 0, 0, PM_SPACE_KBYTE, 0));
 260
 261                 pmiAddMetric("mem.util.available",
 262                              PM_IN_NULL, PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 263                              pmiUnits(1, 0, 0, 0, PM_SPACE_KBYTE, 0));
 264
 265                 pmiAddMetric("mem.util.used",
 266                              PM_IN_NULL, PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 267                              pmiUnits(1, 0, 0, 0, PM_SPACE_KBYTE, 0));
 268
 269                 pmiAddMetric("mem.util.used_pct",
 270                              PM_IN_NULL, PM_TYPE_FLOAT, PM_INDOM_NULL, PM_SEM_INSTANT,
 271                              pmiUnits(0, 0, 0, 0, 0, 0));
 272
 273                 pmiAddMetric("mem.util.buffers",
 274                              PM_IN_NULL, PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 275                              pmiUnits(1, 0, 0, 0, PM_SPACE_KBYTE, 0));
 276
 277                 pmiAddMetric("mem.util.cached",
 278                              PM_IN_NULL, PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 279                              pmiUnits(1, 0, 0, 0, PM_SPACE_KBYTE, 0));
 280
 281                 pmiAddMetric("mem.util.commit",
 282                              PM_IN_NULL, PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 283                              pmiUnits(1, 0, 0, 0, PM_SPACE_KBYTE, 0));
 284
 285                 pmiAddMetric("mem.util.commit_pct",
 286                              PM_IN_NULL, PM_TYPE_FLOAT, PM_INDOM_NULL, PM_SEM_INSTANT,
 287                              pmiUnits(0, 0, 0, 0, 0, 0));
 288
 289                 pmiAddMetric("mem.util.active",
 290                              PM_IN_NULL, PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 291                              pmiUnits(1, 0, 0, 0, PM_SPACE_KBYTE, 0));
 292
 293                 pmiAddMetric("mem.util.inactive",
 294                              PM_IN_NULL, PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 295                              pmiUnits(1, 0, 0, 0, PM_SPACE_KBYTE, 0));
 296
 297                 pmiAddMetric("mem.util.dirty",
 298                              PM_IN_NULL, PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 299                              pmiUnits(1, 0, 0, 0, PM_SPACE_KBYTE, 0));
 300
 301                 if (DISPLAY_MEM_ALL(a->opt_flags)) {
 302
 303                         pmiAddMetric("mem.util.anonpages",
 304                                      PM_IN_NULL, PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 305                                      pmiUnits(1, 0, 0, 0, PM_SPACE_KBYTE, 0));
 306
 307                         pmiAddMetric("mem.util.slab",
 308                                      PM_IN_NULL, PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 309                                      pmiUnits(1, 0, 0, 0, PM_SPACE_KBYTE, 0));
 310
 311                         pmiAddMetric("mem.util.stack",
 312                                      PM_IN_NULL, PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 313                                      pmiUnits(1, 0, 0, 0, PM_SPACE_KBYTE, 0));
 314
 315                         pmiAddMetric("mem.util.pageTables",
 316                                      PM_IN_NULL, PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 317                                      pmiUnits(1, 0, 0, 0, PM_SPACE_KBYTE, 0));
 318
 319                         pmiAddMetric("mem.util.vmused",
 320                                      PM_IN_NULL, PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 321                                      pmiUnits(1, 0, 0, 0, PM_SPACE_KBYTE, 0));
 322                 }
 323         }
 324
 325         if (DISPLAY_SWAP(a->opt_flags)) {
 326
 327                 pmiAddMetric("mem.util.swapFree",
 328                              PM_IN_NULL, PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 329                              pmiUnits(1, 0, 0, 0, PM_SPACE_KBYTE, 0));
 330
 331                 pmiAddMetric("mem.util.swapUsed",
 332                              PM_IN_NULL, PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 333                              pmiUnits(1, 0, 0, 0, PM_SPACE_KBYTE, 0));
 334
 335                 pmiAddMetric("mem.util.swapUsed_pct",
 336                              PM_IN_NULL, PM_TYPE_FLOAT, PM_INDOM_NULL, PM_SEM_INSTANT,
 337                              pmiUnits(0, 0, 0, 0, 0, 0));
 338
 339                 pmiAddMetric("mem.util.swapCached",
 340                              PM_IN_NULL, PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 341                              pmiUnits(1, 0, 0, 0, PM_SPACE_KBYTE, 0));
 342
 343                 pmiAddMetric("mem.util.swapCached_pct",
 344                              PM_IN_NULL, PM_TYPE_FLOAT, PM_INDOM_NULL, PM_SEM_INSTANT,
 345                              pmiUnits(0, 0, 0, 0, 0, 0));
 346         }
 347 #endif /* HAVE_PCP */
 348 }
 349
 350 /*
 351  ***************************************************************************
 352  * Define PCP metrics for queue and load statistics.
 353  ***************************************************************************
 354  */
 355 void pcp_def_queue_metrics(void)
 356 {
 357 #ifdef HAVE_PCP
 358         pmInDom indom;
 359         pmiAddMetric("proc.runq.runnable",
 360                      PM_IN_NULL, PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 361                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 362
 363         pmiAddMetric("proc.nprocs",
 364                      PM_IN_NULL, PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 365                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 366
 367         pmiAddMetric("proc.blocked",
 368                      PM_IN_NULL, PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 369                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 370
 371         indom = pmInDom_build(0, 1);
 372         pmiAddMetric("kernel.all.load",
 373                      PM_IN_NULL, PM_TYPE_FLOAT, indom, PM_SEM_INSTANT,
 374                      pmiUnits(0, 0, 0, 0, 0, 0));
 375         pmiAddInstance(indom, "1 min", 0);
 376         pmiAddInstance(indom, "5 min", 1);
 377         pmiAddInstance(indom, "15 min", 2);
 378 #endif /* HAVE_PCP */
 379 }
 380