cpu plugin: Various, random fixes and improvements:
authorFlorian Forster <octo@collectd.org>
Tue, 16 Sep 2014 07:52:10 +0000 (09:52 +0200)
committerFlorian Forster <octo@collectd.org>
Tue, 16 Sep 2014 07:52:10 +0000 (09:52 +0200)
* Add Pierre-Yves to the list of copyright holders.
* Make sure the entire file is consistently indented.
* Renamed the "ReportActive" config option to "ReportByState"
  (with negated logic).
* Renamed internal functions to better reflect their use.
* Let cpu_stage() (née submit()) work on individual counters / derives
  rather than an array, removing logic from the cpu_read() function.
* Rename CPU_SUBMIT_* to CPU_STATE_*.
* Move legacy behavior it its own function, cpu_commit_without_aggregation().

src/collectd.conf.in
src/collectd.conf.pod
src/cpu.c

index 91c040a..894c64b 100644 (file)
 #</Plugin>
 
 #<Plugin cpu>
-#  ReportActive false
 #  ReportByCpu true
+#  ReportByState true
 #  ValuesPercentage false
 #</Plugin>
 #
index 8ecc92d..d2e6843 100644 (file)
@@ -1207,29 +1207,53 @@ F</proc/sys/net/ipv4/netfilter> instead of F</proc/sys/net/netfilter/>.
 
 =head2 Plugin C<cpu>
 
-The I<CPU plugin> collects CPU usage metrics.
+The I<CPU plugin> collects CPU usage metrics. By default, CPU usage is reported
+as Jiffies, using the C<cpu> type. Two aggregations are available:
+
+=over 4
+
+=item
+
+Sum, per-state, over all CPUs installed in the system; and
+
+=item
+
+Sum, per-CPU, over all non-idle states of a CPU, creating an "active" state.
+
+=back
+
+The two aggregations can be combined, leading to I<collectd> only emitting a
+single "active" metric for the entire system. As soon as one of these
+aggregations (or both) is enabled, the I<cpu plugin> will report a percentage,
+rather than Jiffies. In addition, you can request individual, per-state,
+per-CPU metrics to be reported as percentage.
 
 The following configuration options are available:
 
 =over 4
 
-=item B<ReportActive> B<false>|B<true>
+=item B<ReportByState> B<true>|B<false>
 
-Reports non-idle CPU usage as the "active" value. Defaults to false.
+When set to B<true>, the default, reports per-state metrics, e.g. "system",
+"user" and "idle".
+When set to B<false>, aggregates (sums) all I<non-idle> states into one
+"active" metric.
 
-=item B<ReportByCpu> B<false>|B<true>
+=item B<ReportByCpu> B<true>|B<false>
 
-When true reports usage for all cores. When false, reports cpu usage
-aggregated over all cores.
-Defaults to true.
+When set to B<true>, the default, reports per-CPU (per-core) metrics.
+When set to B<false>, instead of reporting metrics for individual CPUs, only a
+global sum of CPU states is emitted.
 
 =item B<ValuesPercentage> B<false>|B<true>
 
-When true report percentage usage instead of tick values. Defaults to false.
+This option is only considered when both, B<ReportByCpu> and B<ReportByState>
+are set to B<true>. In this case, by default, metrics will be reported as
+Jiffies. By setting this option to B<true>, you can request percentage values
+in the un-aggregated (per-CPU, per-state) mode as well.
 
 =back
 
-
 =head2 Plugin C<cpufreq>
 
 This plugin doesn't have any options. It reads
index b4ceff6..475d18a 100644 (file)
--- a/src/cpu.c
+++ b/src/cpu.c
@@ -1,9 +1,10 @@
 /**
  * collectd - src/cpu.c
- * Copyright (C) 2005-2010  Florian octo Forster
- * Copyright (C) 2008      Oleg King
- * Copyright (C) 2009      Simon Kuhnle
- * Copyright (C) 2009      Manuel Sanmartin
+ * Copyright (C) 2005-2014  Florian octo Forster
+ * Copyright (C) 2008       Oleg King
+ * Copyright (C) 2009       Simon Kuhnle
+ * Copyright (C) 2009       Manuel Sanmartin
+ * Copyright (C) 2013-2014  Pierre-Yves Ritschard
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the
@@ -11,7 +12,7 @@
  *
  * This program is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.         See the GNU
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License along
@@ -23,6 +24,7 @@
  *   Oleg King <king2 at kaluga.ru>
  *   Simon Kuhnle <simon at blarzwurst.de>
  *   Manuel Sanmartin
+ *   Pierre-Yves Ritschard <pyr at spootnik.org>
  **/
 
 #include "collectd.h"
 # define CAN_USE_SYSCTL 0
 #endif
 
-#define CPU_SUBMIT_USER 0
-#define CPU_SUBMIT_SYSTEM 1
-#define CPU_SUBMIT_WAIT 2
-#define CPU_SUBMIT_NICE 3
-#define CPU_SUBMIT_SWAP 4
-#define CPU_SUBMIT_INTERRUPT 5
-#define CPU_SUBMIT_SOFTIRQ 6
-#define CPU_SUBMIT_STEAL 7
-#define CPU_SUBMIT_IDLE 8
-#define CPU_SUBMIT_ACTIVE 9
-#define CPU_SUBMIT_MAX 10
+#define CPU_STATE_USER 0
+#define CPU_STATE_SYSTEM 1
+#define CPU_STATE_WAIT 2
+#define CPU_STATE_NICE 3
+#define CPU_STATE_SWAP 4
+#define CPU_STATE_INTERRUPT 5
+#define CPU_STATE_SOFTIRQ 6
+#define CPU_STATE_STEAL 7
+#define CPU_STATE_IDLE 8
+#define CPU_STATE_ACTIVE 9 /* sum of (!idle) */
+#define CPU_STATE_MAX 10 /* #states */
 
 #if HAVE_STATGRAB_H
 # include <statgrab.h>
@@ -132,8 +134,8 @@ static mach_msg_type_number_t cpu_list_len;
 
 #if PROCESSOR_TEMPERATURE
 static int cpu_temp_retry_counter = 0;
-static int cpu_temp_retry_step   = 1;
-static int cpu_temp_retry_max    = 1;
+static int cpu_temp_retry_step    = 1;
+static int cpu_temp_retry_max     = 1;
 #endif /* PROCESSOR_TEMPERATURE */
 /* #endif PROCESSOR_CPU_LOAD_INFO */
 
@@ -170,82 +172,53 @@ static int numcpu;
 static int pnumcpu;
 #endif /* HAVE_PERFSTAT */
 
-static value_to_rate_state_t *values = NULL;
-static gauge_t agg_values[CPU_SUBMIT_MAX] = {
-       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
+#define RATE_ADD(sum, val) do { \
+       if (isnan (sum))        \
+       (sum) = (val);          \
+       else if (!isnan (val))  \
+       (sum) += (val);         \
+} while (0)
 
+struct cpu_state_s
+{
+       value_to_rate_state_t conv;
+       gauge_t rate;
+       _Bool has_value;
 };
-static int cpu_cells = 0;
-static int cpu_count = 0;
+typedef struct cpu_state_s cpu_state_t;
+
+static cpu_state_t *cpu_states = NULL;
+static size_t cpu_states_num = 0; /* #cpu_states allocated */
 
+/* Highest CPU number in the current iteration. Used by the dispatch logic to
+ * determine how many CPUs there were. Reset to 0 by cpu_reset(). */
+static size_t global_cpu_num = 0;
 
 static _Bool report_by_cpu = 1;
+static _Bool report_by_state = 1;
 static _Bool report_percent = 0;
-static _Bool report_active = 0;
 
 static const char *config_keys[] =
 {
        "ReportByCpu",
-       "ReportActive",
+       "ReportByState",
        "ValuesPercentage"
 };
 static int config_keys_num = STATIC_ARRAY_SIZE (config_keys);
 
-
-static int cpu_config (const char *key, const char *value)
+static int cpu_config (char const *key, char const *value) /* {{{ */
 {
-       if (strcasecmp (key, "ReportByCpu") == 0) {
+       if (strcasecmp (key, "ReportByCpu") == 0)
                report_by_cpu = IS_TRUE (value) ? 1 : 0;
-       }
-       if (strcasecmp (key, "ValuesPercentage") == 0) {
+       else if (strcasecmp (key, "ValuesPercentage") == 0)
                report_percent = IS_TRUE (value) ? 1 : 0;
-       }
-       if (strcasecmp (key, "ReportActive") == 0)
-               report_active = IS_TRUE (value) ? 1 : 0;
-       return (-1);
-}
-
-static int cpu_states_grow (void)
-{
-  void *tmp;
-  int size;
-  int i;
-
-  size = cpu_count * CPU_SUBMIT_MAX; /* always alloc for all states */
-
-  if (size <= 0)
-         return 0;
-
-  if (cpu_cells >= size)
-         return 0;
-
-  if (values == NULL) {
-         values = malloc(size * sizeof(*values));
-         if (values == NULL)
-                 return -1;
-         for (i = 0; i < size; i++)
-                 memset(&values[i], 0, sizeof(*values));
-         cpu_cells = size;
-         return 0;
-  }
-
-  tmp = realloc(values, size * sizeof(*values));
-
-  if (tmp == NULL) {
-         ERROR ("cpu plugin: could not reserve enough space to hold states");
-         values = NULL;
-         return -1;
-  }
-
-  values = tmp;
-
-  for (i = cpu_cells ; i < size; i++)
-         memset(&values[i], 0, sizeof(*values));
-
-  cpu_cells = size;
-  return 0;
-} /* cpu_states_grow */
+       else if (strcasecmp (key, "ReportByState") == 0)
+               report_by_state = IS_TRUE (value) ? 1 : 0;
+       else
+               return (-1);
 
+       return (0);
+} /* }}} int cpu_config */
 
 static int init (void)
 {
@@ -357,11 +330,11 @@ static void submit_value (int cpu_num, int cpu_state, const char *type, value_t
        sstrncpy (vl.plugin, "cpu", sizeof (vl.plugin));
        sstrncpy (vl.type, type, sizeof (vl.type));
        sstrncpy (vl.type_instance, cpu_state_names[cpu_state],
-                 sizeof (vl.type_instance));
+                       sizeof (vl.type_instance));
 
        if (cpu_num >= 0) {
                ssnprintf (vl.plugin_instance, sizeof (vl.plugin_instance),
-                          "%i", cpu_num);
+                               "%i", cpu_num);
        }
        plugin_dispatch_values (&vl);
 }
@@ -382,144 +355,223 @@ static void submit_derive(int cpu_num, int cpu_state, derive_t derive)
        submit_value (cpu_num, cpu_state, "cpu", value);
 }
 
-static void submit_flush (void)
+/* Takes the zero-index number of a CPU and makes sure that the module-global
+ * cpu_states buffer is large enough. Returne ENOMEM on erorr. */
+static int cpu_states_alloc (size_t cpu_num) /* {{{ */
 {
-       int i = 0;
-       int cpu_submit_max = CPU_SUBMIT_MAX;
+       cpu_state_t *tmp;
+       size_t sz;
 
-       if (report_by_cpu) {
-               cpu_count = 0;
-               return;
-       }
+       if (cpu_num < 0)
+               return (EINVAL);
 
-       if (report_active)
-               cpu_submit_max = CPU_SUBMIT_MAX;
-       else
-               cpu_submit_max = CPU_SUBMIT_ACTIVE;
-       for (i = 0; i < cpu_submit_max; i++) {
-               if (agg_values[i] == -1)
-                       continue;
+       sz = (((size_t) cpu_num) + 1) * CPU_STATE_MAX;
+       assert (sz > 0);
 
-               if (report_percent)
-                       submit_percent(-1, i, agg_values[i] / cpu_count);
-               else
-                       submit_derive(-1, i, agg_values[i]);
-               agg_values[i] = -1;
+       /* We already have enough space. */
+       if (cpu_states_num >= sz)
+               return 0;
+
+       tmp = realloc (cpu_states, sz * sizeof (*cpu_states));
+       if (tmp == NULL)
+       {
+               ERROR ("cpu plugin: realloc failed.");
+               return (ENOMEM);
        }
-       cpu_count = 0;
-}
+       cpu_states = tmp;
+       tmp = cpu_states + cpu_states_num;
+
+       memset (tmp, 0, (sz - cpu_states_num) * sizeof (*cpu_states));
+       cpu_states_num = sz;
+       return 0;
+} /* }}} cpu_states_alloc */
 
-static void submit (int cpu_num, derive_t *derives)
+static cpu_state_t *get_cpu_state (size_t cpu_num, size_t state) /* {{{ */
 {
+       size_t index = ((cpu_num * CPU_STATE_MAX) + state);
 
-       int i = 0;
-       int cpu_submit_max = CPU_SUBMIT_MAX;
+       if (index >= cpu_states_num)
+               return (NULL);
 
-       if (report_active)
-               cpu_submit_max = CPU_SUBMIT_MAX;
-       else
-               cpu_submit_max = CPU_SUBMIT_ACTIVE;
+       return (&cpu_states[index]);
+} /* }}} cpu_state_t *get_cpu_state */
+
+/* Populates the per-CPU CPU_STATE_ACTIVE rate and the global rate_by_state
+ * array. */
+static void aggregate (gauge_t *sum_by_state) /* {{{ */
+{
+       size_t cpu_num;
+       size_t state;
 
-       if (!report_percent && report_by_cpu) {
-               derive_t cpu_active = 0;
-               for (i = 0; i < CPU_SUBMIT_ACTIVE; i++)
+       for (state = 0; state < CPU_STATE_MAX; state++)
+               sum_by_state[state] = NAN;
+
+       for (cpu_num = 0; cpu_num < global_cpu_num; cpu_num++)
+       {
+               cpu_state_t *this_cpu_states = get_cpu_state (cpu_num, 0);
+
+               this_cpu_states[CPU_STATE_ACTIVE].rate = NAN;
+
+               for (state = 0; state < CPU_STATE_ACTIVE; state++)
                {
-                       if (derives[i] == -1)
+                       if (!this_cpu_states[state].has_value)
                                continue;
 
-                       if (i != CPU_SUBMIT_IDLE)
-                               cpu_active += derives[i];
-
-                       submit_derive(cpu_num, i, derives[i]);
+                       RATE_ADD (sum_by_state[state], this_cpu_states[state].rate);
+                       if (state != CPU_STATE_IDLE)
+                               RATE_ADD (this_cpu_states[CPU_STATE_ACTIVE].rate, this_cpu_states[state].rate);
                }
-               if (report_active)
-                       submit_derive(cpu_num, CPU_SUBMIT_ACTIVE, cpu_active);
+
+               RATE_ADD (sum_by_state[CPU_STATE_ACTIVE], this_cpu_states[CPU_STATE_ACTIVE].rate);
+       }
+} /* }}} void aggregate */
+
+/* Commits (dispatches) the values for one CPU or the global aggregation.
+ * cpu_num is the index of the CPU to be committed or -1 in case of the global
+ * aggregation. rates is a pointer to CPU_STATE_MAX gauge_t values holding the
+ * current rate; each rate may be NAN. Calculates the percentage of each state
+ * and dispatches the metric. */
+static void cpu_commit_one (int cpu_num, /* {{{ */
+               gauge_t rates[static CPU_STATE_MAX])
+{
+       size_t state;
+       gauge_t sum;
+
+       sum = rates[CPU_STATE_ACTIVE];
+       RATE_ADD (sum, rates[CPU_STATE_IDLE]);
+
+       if (!report_by_state)
+       {
+               gauge_t percent = 100.0 * rates[CPU_STATE_ACTIVE] / sum;
+               submit_percent (cpu_num, CPU_STATE_ACTIVE, percent);
+               return;
        }
-       else {
-               cdtime_t cdt;
-               gauge_t value;
-               gauge_t cpu_total = 0;
-               gauge_t cpu_active = 0;
-               gauge_t local_rates[CPU_SUBMIT_MAX];
-
-               cpu_count++;
-               if (cpu_states_grow())
-                       return;
-
-               memset(local_rates, 0, sizeof(local_rates));
-
-               cdt = cdtime();
-               for (i = 0; i < CPU_SUBMIT_ACTIVE; i++) {
-                       if (report_percent) {
-                               value_t rate;
-                               int index;
-
-                               if (derives[i] == -1)
-                                       continue;
-
-                               index = (cpu_num * CPU_SUBMIT_MAX) + i;
-                               if (value_to_rate(&rate, derives[i], &values[index],
-                                                       DS_TYPE_DERIVE, cdt) != 0) {
-                                       local_rates[i] = -1;
-                                       continue;
-                               }
-
-                               local_rates[i] = rate.gauge;
-                               cpu_total += rate.gauge;
-                               if (i != CPU_SUBMIT_IDLE)
-                                       cpu_active += rate.gauge;
-                       }
-                       else {
-                               cpu_total += derives[i];
-                               if (i != CPU_SUBMIT_IDLE)
-                                       cpu_active += derives[i];
-                       }
-               }
-               if (cpu_total == 0.0)
-                       return;
 
-               if (report_active)
-                       local_rates[CPU_SUBMIT_ACTIVE] = cpu_active;
+       for (state = 0; state < CPU_STATE_ACTIVE; state++)
+       {
+               gauge_t percent = 100.0 * rates[state] / sum;
+               submit_percent (cpu_num, state, percent);
+       }
+} /* }}} void cpu_commit_one */
+
+/* Resets the internal aggregation. This is called by the read callback after
+ * each iteration / after each call to cpu_commit(). */
+static void cpu_reset (void) /* {{{ */
+{
+       size_t i;
+
+       for (i = 0; i < cpu_states_num; i++)
+               cpu_states[i].has_value = 0;
+
+       global_cpu_num = 0;
+} /* }}} void cpu_reset */
+
+/* Legacy behavior: Dispatches the raw derive values without any aggregation. */
+static void cpu_commit_without_aggregation (void) /* {{{ */
+{
+       size_t cpu_num;
 
-               for (i = 0; i < cpu_submit_max; i++) {
-                       if (local_rates[i] == -1)
+       for (cpu_num = 0; cpu_num < global_cpu_num; cpu_num++)
+       {
+               int state;
+
+               for (state = 0; state < CPU_STATE_ACTIVE; state++)
+               {
+                       cpu_state_t *s = get_cpu_state (cpu_num, state);
+
+                       if (!s->has_value)
                                continue;
 
-                       if (report_percent)
-                               value = (local_rates[i] / cpu_total) * 100;
-                       else
-                               value = derives[i];
-                       if (report_by_cpu) {
-                               if (report_percent) {
-                                       submit_percent (cpu_num, i, value);
-                               } else {
-                                       submit_derive(cpu_num, i, value);
-                               }
-                       }
-                       else {
-                               if (agg_values[i] == -1)
-                                       agg_values[i] = value;
-                               else
-                                       agg_values[i] += value;
-                       }
+                       submit_derive ((int) cpu_num, (int) state, s->conv.last_value.derive);
                }
        }
-}
+} /* }}} void cpu_commit_without_aggregation */
+
+/* Aggregates the internal state and dispatches the metrics. */
+static void cpu_commit (void) /* {{{ */
+{
+       gauge_t global_rates[CPU_STATE_MAX] = {
+               NAN, NAN, NAN, NAN, NAN, NAN, NAN, NAN, NAN, NAN
+       };
+       size_t cpu_num;
+
+       if (report_by_cpu && report_by_state && !report_percent)
+       {
+               cpu_commit_without_aggregation ();
+               return;
+       }
+
+       aggregate (global_rates);
+
+       if (!report_by_cpu)
+       {
+               cpu_commit_one (-1, global_rates);
+               return;
+       }
+
+       for (cpu_num = 0; cpu_num < global_cpu_num; cpu_num++)
+       {
+               cpu_state_t *this_cpu_states = get_cpu_state (cpu_num, 0);
+               gauge_t local_rates[CPU_STATE_MAX] = {
+                       NAN, NAN, NAN, NAN, NAN, NAN, NAN, NAN, NAN, NAN
+               };
+               size_t state;
+
+               for (state = 0; state < CPU_STATE_ACTIVE; state++)
+                       if (this_cpu_states[state].has_value)
+                               local_rates[state] = this_cpu_states[state].rate;
+
+               cpu_commit_one ((int) cpu_num, local_rates);
+       }
+} /* }}} void cpu_commit */
+
+/* Adds a derive value to the internal state. This should be used by each read
+ * function for each state. At the end of the iteration, the read function
+ * should call cpu_commit(). */
+static int cpu_stage (size_t cpu_num, size_t state, derive_t value, cdtime_t now) /* {{{ */
+{
+       int status;
+       cpu_state_t *s;
+       value_t v;
+
+       if (state >= CPU_STATE_ACTIVE)
+               return (EINVAL);
+
+       status = cpu_states_alloc (cpu_num);
+       if (status != 0)
+               return (status);
+
+       if (global_cpu_num <= cpu_num)
+               global_cpu_num = cpu_num + 1;
+
+       s = get_cpu_state (cpu_num, state);
+
+       v.gauge = NAN;
+       status = value_to_rate (&v, value, &s->conv, DS_TYPE_DERIVE, now);
+       if (status != 0)
+               return (status);
+
+       s->rate = v.gauge;
+       s->has_value = 1;
+       return (0);
+} /* }}} int cpu_stage */
 
 static int cpu_read (void)
 {
-#if PROCESSOR_CPU_LOAD_INFO || PROCESSOR_TEMPERATURE
+       cdtime_t now = cdtime ();
+
+#if PROCESSOR_CPU_LOAD_INFO || PROCESSOR_TEMPERATURE /* {{{ */
        int cpu;
 
        kern_return_t status;
 
 #if PROCESSOR_CPU_LOAD_INFO
        processor_cpu_load_info_data_t cpu_info;
-       mach_msg_type_number_t         cpu_info_len;
+       mach_msg_type_number_t         cpu_info_len;
 #endif
 #if PROCESSOR_TEMPERATURE
-       processor_info_data_t          cpu_temp;
-       mach_msg_type_number_t         cpu_temp_len;
+       processor_info_data_t          cpu_temp;
+       mach_msg_type_number_t         cpu_temp_len;
 #endif
 
        host_t cpu_host;
@@ -527,10 +579,6 @@ static int cpu_read (void)
        for (cpu = 0; cpu < cpu_list_len; cpu++)
        {
 #if PROCESSOR_CPU_LOAD_INFO
-               derive_t derives[CPU_SUBMIT_MAX] = {
-                       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
-               };
-               memset(derives, -1, sizeof(derives));
                cpu_host = 0;
                cpu_info_len = PROCESSOR_BASIC_INFO_COUNT;
 
@@ -548,13 +596,12 @@ static int cpu_read (void)
                        continue;
                }
 
-               derives[CPU_SUBMIT_USER] = (derive_t) cpu_info.cpu_ticks[CPU_STATE_USER];
-               derives[CPU_SUBMIT_NICE] = (derive_t) cpu_info.cpu_ticks[CPU_STATE_NICE];
-               derives[CPU_SUBMIT_SYSTEM] = (derive_t) cpu_info.cpu_ticks[CPU_STATE_SYSTEM];
-               derives[CPU_SUBMIT_IDLE] = (derive_t) cpu_info.cpu_ticks[CPU_STATE_IDLE];
-               submit (cpu, derives);
-
+               cpu_stage (cpu, CPU_STATE_USER,   (derive_t) cpu_info.cpu_ticks[CPU_STATE_USER],   now);
+               cpu_stage (cpu, CPU_STATE_NICE,   (derive_t) cpu_info.cpu_ticks[CPU_STATE_NICE],   now);
+               cpu_stage (cpu, CPU_STATE_SYSTEM, (derive_t) cpu_info.cpu_ticks[CPU_STATE_SYSTEM], now);
+               cpu_stage (cpu, CPU_STATE_IDLE,   (derive_t) cpu_info.cpu_ticks[CPU_STATE_IDLE],   now);
 #endif /* PROCESSOR_CPU_LOAD_INFO */
+
 #if PROCESSOR_TEMPERATURE
                /*
                 * Not all Apple computers do have this ability. To minimize
@@ -598,10 +645,9 @@ static int cpu_read (void)
                cpu_temp_retry_step    = 1;
 #endif /* PROCESSOR_TEMPERATURE */
        }
-       submit_flush ();
-/* #endif PROCESSOR_CPU_LOAD_INFO */
+/* }}} #endif PROCESSOR_CPU_LOAD_INFO */
 
-#elif defined(KERNEL_LINUX)
+#elif defined(KERNEL_LINUX) /* {{{ */
        int cpu;
        FILE *fh;
        char buf[1024];
@@ -619,10 +665,6 @@ static int cpu_read (void)
 
        while (fgets (buf, 1024, fh) != NULL)
        {
-               derive_t derives[CPU_SUBMIT_MAX] = {
-                       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
-               };
-
                if (strncmp (buf, "cpu", 3))
                        continue;
                if ((buf[3] < '0') || (buf[3] > '9'))
@@ -633,28 +675,26 @@ static int cpu_read (void)
                        continue;
 
                cpu = atoi (fields[0] + 3);
-               derives[CPU_SUBMIT_USER] = atoll(fields[1]);
-               derives[CPU_SUBMIT_NICE] = atoll(fields[2]);
-               derives[CPU_SUBMIT_SYSTEM] = atoll(fields[3]);
-               derives[CPU_SUBMIT_IDLE] = atoll(fields[4]);
+
+               cpu_stage (cpu, CPU_STATE_USER,   (derive_t) atoll(fields[1]), now);
+               cpu_stage (cpu, CPU_STATE_NICE,   (derive_t) atoll(fields[2]), now);
+               cpu_stage (cpu, CPU_STATE_SYSTEM, (derive_t) atoll(fields[3]), now);
+               cpu_stage (cpu, CPU_STATE_IDLE,   (derive_t) atoll(fields[4]), now);
 
                if (numfields >= 8)
                {
-                       derives[CPU_SUBMIT_WAIT] = atoll(fields[5]);
-                       derives[CPU_SUBMIT_INTERRUPT] = atoll(fields[6]);
-                       derives[CPU_SUBMIT_SOFTIRQ] = atoll(fields[7]);
+                       cpu_stage (cpu, CPU_STATE_WAIT,      (derive_t) atoll(fields[5]), now);
+                       cpu_stage (cpu, CPU_STATE_INTERRUPT, (derive_t) atoll(fields[6]), now);
+                       cpu_stage (cpu, CPU_STATE_SOFTIRQ,   (derive_t) atoll(fields[7]), now);
 
                        if (numfields >= 9)
-                               derives[CPU_SUBMIT_STEAL] = atoll(fields[8]);
+                               cpu_stage (cpu, CPU_STATE_STEAL, (derive_t) atoll(fields[8]), now);
                }
-               submit(cpu, derives);
        }
-       submit_flush();
-
        fclose (fh);
-/* #endif defined(KERNEL_LINUX) */
+/* }}} #endif defined(KERNEL_LINUX) */
 
-#elif defined(HAVE_LIBKSTAT)
+#elif defined(HAVE_LIBKSTAT) /* {{{ */
        int cpu;
        static cpu_stat_t cs;
 
@@ -663,24 +703,17 @@ static int cpu_read (void)
 
        for (cpu = 0; cpu < numcpu; cpu++)
        {
-               derive_t derives[CPU_SUBMIT_MAX] = {
-                       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
-               };
-
                if (kstat_read (kc, ksp[cpu], &cs) == -1)
                        continue; /* error message? */
 
-               memset(derives, -1, sizeof(derives));
-               derives[CPU_SUBMIT_IDLE] = cs.cpu_sysinfo.cpu[CPU_IDLE];
-               derives[CPU_SUBMIT_USER] = cs.cpu_sysinfo.cpu[CPU_USER];
-               derives[CPU_SUBMIT_SYSTEM] = cs.cpu_sysinfo.cpu[CPU_KERNEL];
-               derives[CPU_SUBMIT_WAIT] = cs.cpu_sysinfo.cpu[CPU_WAIT];
-               submit (ksp[cpu]->ks_instance, derives);
+               cpu_stage (ksp[cpu]->ks_instance, CPU_STATE_IDLE,   (derive_t) cs.cpu_sysinfo.cpu[CPU_IDLE],   now);
+               cpu_stage (ksp[cpu]->ks_instance, CPU_STATE_USER,   (derive_t) cs.cpu_sysinfo.cpu[CPU_USER],   now);
+               cpu_stage (ksp[cpu]->ks_instance, CPU_STATE_SYSTEM, (derive_t) cs.cpu_sysinfo.cpu[CPU_KERNEL], now);
+               cpu_stage (ksp[cpu]->ks_instance, CPU_STATE_WAIT,   (derive_t) cs.cpu_sysinfo.cpu[CPU_WAIT],   now);
        }
-       submit_flush ();
-/* #endif defined(HAVE_LIBKSTAT) */
+/* }}} #endif defined(HAVE_LIBKSTAT) */
 
-#elif CAN_USE_SYSCTL
+#elif CAN_USE_SYSCTL /* {{{ */
        uint64_t cpuinfo[numcpu][CPUSTATES];
        size_t cpuinfo_size;
        int status;
@@ -736,20 +769,15 @@ static int cpu_read (void)
        }
 
        for (i = 0; i < numcpu; i++) {
-               derive_t derives[CPU_SUBMIT_MAX] = {
-                       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
-               };
-
-               derives[CPU_SUBMIT_USER] = cpuinfo[i][CP_USER];
-               derives[CPU_SUBMIT_NICE] = cpuinfo[i][CP_NICE];
-               derives[CPU_SUBMIT_SYSTEM] = cpuinfo[i][CP_SYS];
-               derives[CPU_SUBMIT_IDLE] = cpuinfo[i][CP_IDLE];
-               derives[CPU_SUBMIT_INTERRUPT] = cpuinfo[i][CP_INTR];
-               submit(i, derives);
+               cpu_state (i, CPU_STATE_USER,      (derive_t) cpuinfo[i][CP_USER]);
+               cpu_state (i, CPU_STATE_NICE,      (derive_t) cpuinfo[i][CP_NICE]);
+               cpu_state (i, CPU_STATE_SYSTEM,    (derive_t) cpuinfo[i][CP_SYS]);
+               cpu_state (i, CPU_STATE_IDLE,      (derive_t) cpuinfo[i][CP_IDLE]);
+               cpu_state (i, CPU_STATE_INTERRUPT, (derive_t) cpuinfo[i][CP_INTR]);
        }
-       submit_flush();
-/* #endif CAN_USE_SYSCTL */
-#elif defined(HAVE_SYSCTLBYNAME) && defined(HAVE_SYSCTL_KERN_CP_TIMES)
+/* }}} #endif CAN_USE_SYSCTL */
+
+#elif defined(HAVE_SYSCTLBYNAME) && defined(HAVE_SYSCTL_KERN_CP_TIMES) /* {{{ */
        long cpuinfo[maxcpu][CPUSTATES];
        size_t cpuinfo_size;
        int i;
@@ -766,26 +794,17 @@ static int cpu_read (void)
        }
 
        for (i = 0; i < numcpu; i++) {
-               derive_t derives[CPU_SUBMIT_MAX] = {
-                       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
-               };
-
-               derives[CPU_SUBMIT_USER] = cpuinfo[i][CP_USER];
-               derives[CPU_SUBMIT_NICE] = cpuinfo[i][CP_NICE];
-               derives[CPU_SUBMIT_SYSTEM] = cpuinfo[i][CP_SYS];
-               derives[CPU_SUBMIT_IDLE] = cpuinfo[i][CP_IDLE];
-               derives[CPU_SUBMIT_INTERRUPT] = cpuinfo[i][CP_INTR];
-               submit(i, derives);
+               cpu_state (i, CPU_STATE_USER,      (derive_t) cpuinfo[i][CP_USER]);
+               cpu_state (i, CPU_STATE_NICE,      (derive_t) cpuinfo[i][CP_NICE]);
+               cpu_state (i, CPU_STATE_SYSTEM,    (derive_t) cpuinfo[i][CP_SYS]);
+               cpu_state (i, CPU_STATE_IDLE,      (derive_t) cpuinfo[i][CP_IDLE]);
+               cpu_state (i, CPU_STATE_INTERRUPT, (derive_t) cpuinfo[i][CP_INTR]);
        }
-       submit_flush();
+/* }}} #endif HAVE_SYSCTL_KERN_CP_TIMES */
 
-/* #endif HAVE_SYSCTL_KERN_CP_TIMES */
-#elif defined(HAVE_SYSCTLBYNAME)
+#elif defined(HAVE_SYSCTLBYNAME) /* {{{ */
        long cpuinfo[CPUSTATES];
        size_t cpuinfo_size;
-       derive_t derives[CPU_SUBMIT_MAX] = {
-               -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
-       };
 
        cpuinfo_size = sizeof (cpuinfo);
 
@@ -797,21 +816,15 @@ static int cpu_read (void)
                return (-1);
        }
 
-       derives[CPU_SUBMIT_USER] = cpuinfo[CP_USER];
-       derives[CPU_SUBMIT_SYSTEM] = cpuinfo[CP_SYS];
-       derives[CPU_SUBMIT_NICE] = cpuinfo[CP_NICE];
-       derives[CPU_SUBMIT_IDLE] = cpuinfo[CP_IDLE];
-       derives[CPU_SUBMIT_INTERRUPT] = cpuinfo[CP_INTR];
-       submit(0, derives);
-       submit_flush();
-
-/* #endif HAVE_SYSCTLBYNAME */
+       cpu_state (0, CPU_STATE_USER,      (derive_t) cpuinfo[CP_USER]);
+       cpu_state (0, CPU_STATE_NICE,      (derive_t) cpuinfo[CP_NICE]);
+       cpu_state (0, CPU_STATE_SYSTEM,    (derive_t) cpuinfo[CP_SYS]);
+       cpu_state (0, CPU_STATE_IDLE,      (derive_t) cpuinfo[CP_IDLE]);
+       cpu_state (0, CPU_STATE_INTERRUPT, (derive_t) cpuinfo[CP_INTR]);
+/* }}} #endif HAVE_SYSCTLBYNAME */
 
-#elif defined(HAVE_LIBSTATGRAB)
+#elif defined(HAVE_LIBSTATGRAB) /* {{{ */
        sg_cpu_stats *cs;
-       derive_t derives[CPU_SUBMIT_MAX] = {
-               -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
-       };
        cs = sg_get_cpu_stats ();
 
        if (cs == NULL)
@@ -820,17 +833,15 @@ static int cpu_read (void)
                return (-1);
        }
 
-       derives[CPU_SUBMIT_IDLE] = (derive_t) cs->idle;
-       derives[CPU_SUBMIT_NICE] = (derive_t) cs->nice;
-       derives[CPU_SUBMIT_SWAP] = (derive_t) cs->swap;
-       derives[CPU_SUBMIT_SYSTEM] = (derive_t) cs->kernel;
-       derives[CPU_SUBMIT_USER] = (derive_t) cs->user;
-       derives[CPU_SUBMIT_WAIT] = (derive_t) cs->iowait;
-       submit(0, derives);
-       submit_flush();
-/* #endif HAVE_LIBSTATGRAB */
+       cpu_state (0, CPU_STATE_IDLE,   (derive_t) cs->idle);
+       cpu_state (0, CPU_STATE_NICE,   (derive_t) cs->nice);
+       cpu_state (0, CPU_STATE_SWAP,   (derive_t) cs->swap);
+       cpu_state (0, CPU_STATE_SYSTEM, (derive_t) cs->kernel);
+       cpu_state (0, CPU_STATE_USER,   (derive_t) cs->user);
+       cpu_state (0, CPU_STATE_WAIT,   (derive_t) cs->iowait);
+/* }}} #endif HAVE_LIBSTATGRAB */
 
-#elif defined(HAVE_PERFSTAT)
+#elif defined(HAVE_PERFSTAT) /* {{{ */
        perfstat_id_t id;
        int i, cpus;
 
@@ -862,18 +873,15 @@ static int cpu_read (void)
 
        for (i = 0; i < cpus; i++)
        {
-               derive_t derives[CPU_SUBMIT_MAX] = {
-                       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
-               };
-               derives[CPU_SUBMIT_IDLE] = perfcpu[i].idle;
-               derives[CPU_SUBMIT_SYSTEM] = perfcpu[i].sys;
-               derives[CPU_SUBMIT_USER] = perfcpu[i].user;
-               derives[CPU_SUBMIT_WAIT] = perfcpu[i].wait;
-               submit(i, derives);
+               cpu_stage (i, CPU_STATE_IDLE,   (derive_t) perfcpu[i].idle, now);
+               cpu_stage (i, CPU_STATE_SYSTEM, (derive_t) perfcpu[i].sys,  now);
+               cpu_stage (i, CPU_STATE_USER,   (derive_t) perfcpu[i].user, now);
+               cpu_stage (i, CPU_STATE_WAIT,   (derive_t) perfcpu[i].wait, now);
        }
-       submit_flush();
-#endif /* HAVE_PERFSTAT */
+#endif /* }}} HAVE_PERFSTAT */
 
+       cpu_commit ();
+       cpu_reset ();
        return (0);
 }
 
@@ -883,3 +891,5 @@ void module_register (void)
        plugin_register_config ("cpu", cpu_config, config_keys, config_keys_num);
        plugin_register_read ("cpu", cpu_read);
 } /* void module_register */
+
+/* vim: set sw=8 sts=8 noet fdm=marker : */