![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: 8b618e1)
raw | patch | inline | side by side (parent: 8b618e1)
| author | Florian Forster <octo@collectd.org> | |
| Tue, 16 Sep 2014 07:52:10 +0000 (09:52 +0200) | ||
| committer | Florian 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().
* 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 | patch | blob | history | |
| src/collectd.conf.pod | patch | blob | history | |
| src/cpu.c | patch | blob | history |
diff --git a/src/collectd.conf.in b/src/collectd.conf.in
index 91c040a3ca67a144ba573c4faaf2d5ef5f926c23..894c64ba87d671d86af47a249f5da14152b63760 100644 (file)
--- a/src/collectd.conf.in
+++ b/src/collectd.conf.in
#</Plugin>
#<Plugin cpu>
-# ReportActive false
# ReportByCpu true
+# ReportByState true
# ValuesPercentage false
#</Plugin>
#
diff --git a/src/collectd.conf.pod b/src/collectd.conf.pod
index 8ecc92d647ff7a38c5ea9310560d29b05ef9bfb4..d2e6843b858807c78ae9e9cd50a1e202fd3479ea 100644 (file)
--- a/src/collectd.conf.pod
+++ b/src/collectd.conf.pod
=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
diff --git a/src/cpu.c b/src/cpu.c
index b4ceff64ce40dba8a51d88d14a028f5eefc25a3a..475d18ac4e8a83e2d51642da667acf5713c5e338 100644 (file)
--- a/src/cpu.c
+++ b/src/cpu.c
/**
* 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
*
* 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
* 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>
#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 */
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);
}
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;
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;
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
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];
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'))
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;
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;
}
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;
}
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);
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)
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;
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);
}
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 : */