Tree wide: Remove `fpcounter_t` and use `double` instead.

diff --git a/src/cpu.c b/src/cpu.c
index 90a891389e7eb66d91cb2e8ac37a098c55d15f0a..d2cdb7dfb53d45b16041e73be74c7dfafbdf1ef4 100644 (file)
--- a/src/cpu.c
+++ b/src/cpu.c
@@ -139,7 +139,7 @@ typedef struct {
 
   /* count is a scaled counter, so that all states in sum increase by 1000000
    * per second. */
-  fpcounter_t count;
+  double count;
   bool has_count;
   rate_to_value_state_t to_count;
 } usage_state_t;
@@ -554,7 +554,7 @@ static gauge_t usage_ratio(usage_t *u, size_t cpu, state_t state) {
   return usage_rate(u, cpu, state) / global_rate;
 }
 
-static fpcounter_t usage_count(usage_t *u, size_t cpu, state_t state) {
+static double usage_count(usage_t *u, size_t cpu, state_t state) {
   usage_finalize(u);
 
   usage_state_t us;
@@ -610,7 +610,7 @@ static void commit_cpu_usage(usage_t *u, size_t cpu_num) {
 
   if (report_by_state) {
     for (state_t state = 0; state < STATE_ACTIVE; state++) {
-      fpcounter_t usage = usage_count(u, cpu_num, state);
+      double usage = usage_count(u, cpu_num, state);
       if (isnan(usage)) {
         continue;
       }
@@ -618,7 +618,7 @@ static void commit_cpu_usage(usage_t *u, size_t cpu_num) {
                            (value_t){.counter_fp = usage}, &m);
     }
   } else {
-    fpcounter_t usage = usage_count(u, cpu_num, STATE_ACTIVE);
+    double usage = usage_count(u, cpu_num, STATE_ACTIVE);
     if (!isnan(usage)) {
       metric_family_append(&fam, label_state, cpu_state_names[STATE_ACTIVE],
                            (value_t){.counter_fp = usage}, &m);

diff --git a/src/cpu_test.c b/src/cpu_test.c
index cab4e23c7f6abf73b31bd586c899e0c1772e5123..a0f9f8aa2dba0f04476dc6e7b4fec1a86f0ec5e1 100644 (file)
--- a/src/cpu_test.c
+++ b/src/cpu_test.c
@@ -124,7 +124,7 @@ DEF_TEST(usage_ratio) {
   return 0;
 }
 
-static bool expect_usage_count(fpcounter_t want, fpcounter_t got, size_t cpu,
+static bool expect_usage_count(double want, double got, size_t cpu,
                                state_t state) {
   char cpu_str[64] = "CPU_ALL";
   if (cpu != SIZE_MAX) {
@@ -174,8 +174,8 @@ DEF_TEST(usage_count) {
     }
   }
 
-  fpcounter_t state_time[STATE_MAX] = {0};
-  fpcounter_t sum_time = 0;
+  double state_time[STATE_MAX] = {0};
+  double sum_time = 0;
   for (size_t cpu = 0; cpu < CPU_NUM; cpu++) {
     derive_t active_increment = 0;
     for (state_t s = 0; s < STATE_ACTIVE; s++) {
@@ -184,9 +184,8 @@ DEF_TEST(usage_count) {
         active_increment += increment;
       }
 
-      fpcounter_t want_time = CDTIME_T_TO_DOUBLE(interval) *
-                              ((fpcounter_t)increment) /
-                              ((fpcounter_t)cpu_increment[cpu]);
+      double want_time = CDTIME_T_TO_DOUBLE(interval) * ((double)increment) /
+                         ((double)cpu_increment[cpu]);
       state_time[s] += want_time;
       sum_time += want_time;
 
@@ -195,9 +194,9 @@ DEF_TEST(usage_count) {
       ret = ret || !ok;
     }
 
-    fpcounter_t want_active_time = CDTIME_T_TO_DOUBLE(interval) *
-                                   ((fpcounter_t)active_increment) /
-                                   ((fpcounter_t)cpu_increment[cpu]);
+    double want_active_time = CDTIME_T_TO_DOUBLE(interval) *
+                              ((double)active_increment) /
+                              ((double)cpu_increment[cpu]);
     state_time[STATE_ACTIVE] += want_active_time;
     bool ok = expect_usage_count(want_active_time,
                                  usage_count(&usage, cpu, STATE_ACTIVE), cpu,

diff --git a/src/daemon/metric.h b/src/daemon/metric.h
index dce8797340b9b5147b3b73a372c004037bf1e509..e98c2c0d10ed4e95a8a3bcdd7abad245a9336a09 100644 (file)
--- a/src/daemon/metric.h
+++ b/src/daemon/metric.h
@@ -70,13 +70,12 @@ typedef enum {
 
 typedef double gauge_t;
 typedef uint64_t counter_t;
-typedef double fpcounter_t;
 typedef int64_t derive_t;
 
 union value_u {
   gauge_t gauge;
   counter_t counter;
-  fpcounter_t counter_fp;
+  double counter_fp;
   int64_t up_down;
   double up_down_fp;
   // For collectd 5 compatiblity. Treated the same as up_down.

diff --git a/src/disk.c b/src/disk.c
index 2510df4f61d8a77cb986052230b250392bfa57f7..a5dd4f22a14b0ba04d50c900936fd6b26625bb1b 100644 (file)
--- a/src/disk.c
+++ b/src/disk.c
@@ -592,10 +592,10 @@ static int disk_read(void) {
     if ((read_time_ns != -1LL) || (write_time_ns != -1LL)) {
       metric_family_append(
           &fam_ops_time, direction_label, read_direction,
-          (value_t){.counter_fp = ((fpcounter_t)read_time_ns) / 1e9}, &m);
+          (value_t){.counter_fp = ((double)read_time_ns) / 1e9}, &m);
       metric_family_append(
           &fam_ops_time, direction_label, write_direction,
-          (value_t){.counter_fp = ((fpcounter_t)write_time_ns) / 1e9}, &m);
+          (value_t){.counter_fp = ((double)write_time_ns) / 1e9}, &m);
     }
     metric_reset(&m);
   }
@@ -721,11 +721,9 @@ static int disk_read(void) {
         devstat_compute_etime(&snap_iter->duration[DEVSTAT_WRITE], NULL);
     if ((read_time_s != 0) || (write_time_s != 0)) {
       metric_family_append(&fam_ops_time, direction_label, read_direction,
-                           (value_t){.counter_fp = (fpcounter_t)read_time_s},
-                           &m);
+                           (value_t){.counter_fp = (double)read_time_s}, &m);
       metric_family_append(&fam_ops_time, direction_label, write_direction,
-                           (value_t){.counter_fp = (fpcounter_t)write_time_s},
-                           &m);
+                           (value_t){.counter_fp = (double)write_time_s}, &m);
     }
 
     long double busy_time = 0, utilization = 0, total_duration_s = 0;
@@ -736,13 +734,13 @@ static int disk_read(void) {
             DSM_QUEUE_LENGTH, &queue_length, DSM_NONE) != 0) {
       WARNING("%s", devstat_errbuf);
     } else {
-      m.value.counter_fp = (fpcounter_t)busy_time;
+      m.value.counter_fp = (double)busy_time;
       metric_family_metric_append(&fam_disk_io_time, m);
 
       m.value.gauge = (gauge_t)utilization;
       metric_family_metric_append(&fam_utilization, m);
 
-      m.value.counter_fp = (fpcounter_t)total_duration_s;
+      m.value.counter_fp = (double)total_duration_s;
       metric_family_metric_append(&fam_disk_io_weighted_time, m);
 
       m.value.gauge = (gauge_t)queue_length;
@@ -899,10 +897,10 @@ static int disk_read(void) {
     if ((read_time_ms != 0) || (write_time_ms != 0)) {
       metric_family_append(
           &fam_ops_time, direction_label, read_direction,
-          (value_t){.counter_fp = ((fpcounter_t)read_time_ms) / 1000}, &m);
+          (value_t){.counter_fp = ((double)read_time_ms) / 1000}, &m);
       metric_family_append(
           &fam_ops_time, direction_label, write_direction,
-          (value_t){.counter_fp = ((fpcounter_t)write_time_ms) / 1000}, &m);
+          (value_t){.counter_fp = ((double)write_time_ms) / 1000}, &m);
     }
 
     if (read_merged != 0 || write_merged != 0) {
@@ -918,12 +916,12 @@ static int disk_read(void) {
     }
 
     if (io_time_ms != 0) {
-      m.value.counter_fp = ((fpcounter_t)io_time_ms) / 1000.0;
+      m.value.counter_fp = ((double)io_time_ms) / 1000.0;
       metric_family_metric_append(&fam_disk_io_time, m);
     }
 
     if (weighted_time_ms != 0) {
-      m.value.counter_fp = ((fpcounter_t)weighted_time_ms) / 1000.0;
+      m.value.counter_fp = ((double)weighted_time_ms) / 1000.0;
       metric_family_metric_append(&fam_disk_io_weighted_time, m);
     }
 
@@ -1012,11 +1010,11 @@ static int disk_read(void) {
 
     if (strncmp(ksp[i]->ks_class, "disk", strlen("disk")) == 0) {
       hrtime_t run_time_ns = kio.rtime;
-      m.value.counter_fp = ((fpcounter_t)run_time_ns) / 1e9;
+      m.value.counter_fp = ((double)run_time_ns) / 1e9;
       metric_family_metric_append(&fam_disk_io_time, m);
 
       hrtime_t weighted_io_time_ns = kio.rlentime;
-      m.value.counter_fp = ((fpcounter_t)weighted_io_time_ns) / 1e9;
+      m.value.counter_fp = ((double)weighted_io_time_ns) / 1e9;
       metric_family_metric_append(&fam_disk_io_weighted_time, m);
 
       uint_t ops_waiting = kio.wcnt;
@@ -1110,12 +1108,12 @@ static int disk_read(void) {
                             _system_configuration.Xfrac;
     derive_t write_time_ns = stat_disk[i].wserv * _system_configuration.Xint /
                              _system_configuration.Xfrac;
-    metric_family_append(
-        &fam_ops_time, direction_label, read_direction,
-        (value_t){.counter_fp = ((fpcounter_t)read_time_ns) / 1e9}, &m);
-    metric_family_append(
-        &fam_ops_time, direction_label, write_direction,
-        (value_t){.counter_fp = ((fpcounter_t)write_time_ns) / 1e9}, &m);
+    metric_family_append(&fam_ops_time, direction_label, read_direction,
+                         (value_t){.counter_fp = ((double)read_time_ns) / 1e9},
+                         &m);
+    metric_family_append(&fam_ops_time, direction_label, write_direction,
+                         (value_t){.counter_fp = ((double)write_time_ns) / 1e9},
+                         &m);
 
     metric_reset(&m);
   }
@@ -1176,8 +1174,8 @@ static int disk_read(void) {
     metric_family_append(&fam_ops, direction_label, write_direction,
                          (value_t){.counter = drives[i].wxfer}, &m);
 
-    m.value.counter_fp = ((fpcounter_t)drives[i].time_sec) +
-                         ((fpcounter_t)drives[i].time_usec) / 1e6;
+    m.value.counter_fp =
+        ((double)drives[i].time_sec) + ((double)drives[i].time_usec) / 1e6;
     metric_family_metric_append(&fam_disk_io_time, m);
 
     metric_reset(&m);

diff --git a/src/utils/common/common.c b/src/utils/common/common.c
index 16785390ceafaac6c835443e4c2637bb269aeb34..e55c9f7218edbdf286d6fddbdf723da0929e49f8 100644 (file)
--- a/src/utils/common/common.c
+++ b/src/utils/common/common.c
@@ -965,7 +965,7 @@ int parse_value(char const *value, value_t *ret_value, metric_type_t type) {
     break;
 
   case METRIC_TYPE_COUNTER_FP:
-    ret_value->counter_fp = (fpcounter_t)strtod(value, &endptr);
+    ret_value->counter_fp = (double)strtod(value, &endptr);
     break;
 
   case METRIC_TYPE_UP_DOWN:
@@ -1235,7 +1235,7 @@ int rate_to_value(value_t *ret_value, gauge_t rate, /* {{{ */
       state->residual = rate - ((gauge_t)state->last_value.counter);
       break;
     case METRIC_TYPE_COUNTER_FP:
-      state->last_value.counter_fp = (fpcounter_t)rate;
+      state->last_value.counter_fp = (double)rate;
       state->residual = 0;
       break;
     case METRIC_TYPE_UP_DOWN:
@@ -1266,7 +1266,7 @@ int rate_to_value(value_t *ret_value, gauge_t rate, /* {{{ */
     break;
   }
   case METRIC_TYPE_COUNTER_FP: {
-    fpcounter_t delta = (fpcounter_t)delta_gauge;
+    double delta = (double)delta_gauge;
     state->last_value.counter_fp += delta;
     state->residual = 0;
     break;
@@ -1309,7 +1309,7 @@ static int calculate_rate(gauge_t *ret_rate, value_t value, metric_type_t type,
       *ret_rate = NAN;
       return EAGAIN;
     }
-    fpcounter_t diff = value.counter_fp - state->last_value.counter_fp;
+    double diff = value.counter_fp - state->last_value.counter_fp;
     *ret_rate = ((gauge_t)diff) / ((gauge_t)interval);
     return 0;
   }

diff --git a/src/utils/common/common_test.c b/src/utils/common/common_test.c
index ecbf4993953adc947d98f8d69c1aa564862bbffc..4f370aa0b4f1d11757e3c65540febf97a8fc151c 100644 (file)
--- a/src/utils/common/common_test.c
+++ b/src/utils/common/common_test.c
@@ -543,7 +543,7 @@ DEF_TEST(value_to_rate) {
           .want = 10.0,
       },
       {
-          .name = "fpcounter_t init",
+          .name = "double init",
           .t0 = 0,
           .t1 = 10,
           .type = METRIC_TYPE_COUNTER_FP,
@@ -552,7 +552,7 @@ DEF_TEST(value_to_rate) {
           .want_err = EAGAIN,
       },
       {
-          .name = "fpcounter_t increase",
+          .name = "double increase",
           .t0 = 10,
           .t1 = 20,
           .type = METRIC_TYPE_COUNTER_FP,
@@ -561,7 +561,7 @@ DEF_TEST(value_to_rate) {
           .want = (50.5 - 10.) / (20. - 10.),
       },
       {
-          .name = "fpcounter_t reset",
+          .name = "double reset",
           .t0 = 20,
           .t1 = 30,
           .type = METRIC_TYPE_COUNTER_FP,

diff --git a/src/utils/format_stackdriver/format_stackdriver.c b/src/utils/format_stackdriver/format_stackdriver.c
index 77d6972a010ff230fb89b36fd71e3ef2fe252b5f..642777b126c8548148185fec58f28a75d023b8ba 100644 (file)
--- a/src/utils/format_stackdriver/format_stackdriver.c
+++ b/src/utils/format_stackdriver/format_stackdriver.c
@@ -159,7 +159,7 @@ static int format_typed_value(yajl_gen gen, metric_t const *m,
     /* Counter resets are handled in format_time_series(). */
     assert(m->value.counter_fp >= start_value.counter_fp);
 
-    fpcounter_t diff = m->value.counter_fp - start_value.counter_fp;
+    double diff = m->value.counter_fp - start_value.counter_fp;
     int status = json_string(gen, "doubleValue") || yajl_gen_double(gen, diff);
     if (status != 0) {
       return status;