Code

Merge remote-tracking branch 'github/pr/387'
[collectd.git] / src / utils_latency.c
1 /**
2  * collectd - src/utils_latency.c
3  * Copyright (C) 2013  Florian Forster
4  *
5  * Permission is hereby granted, free of charge, to any person obtaining a
6  * copy of this software and associated documentation files (the "Software"),
7  * to deal in the Software without restriction, including without limitation
8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9  * and/or sell copies of the Software, and to permit persons to whom the
10  * Software is furnished to do so, subject to the following conditions:
11  *
12  * The above copyright notice and this permission notice shall be included in
13  * all copies or substantial portions of the Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21  * DEALINGS IN THE SOFTWARE.
22  *
23  * Authors:
24  *   Florian Forster <ff at octo.it>
25  **/
27 #include "collectd.h"
28 #include "utils_latency.h"
29 #include "common.h"
31 #ifndef LATENCY_HISTOGRAM_SIZE
32 # define LATENCY_HISTOGRAM_SIZE 1000
33 #endif
35 struct latency_counter_s
36 {
37   cdtime_t start_time;
39   cdtime_t sum;
40   size_t num;
42   cdtime_t min;
43   cdtime_t max;
45   int histogram[LATENCY_HISTOGRAM_SIZE];
46 };
48 latency_counter_t *latency_counter_create () /* {{{ */
49 {
50   latency_counter_t *lc;
52   lc = malloc (sizeof (*lc));
53   if (lc == NULL)
54     return (NULL);
56   latency_counter_reset (lc);
57   return (lc);
58 } /* }}} latency_counter_t *latency_counter_create */
60 void latency_counter_destroy (latency_counter_t *lc) /* {{{ */
61 {
62   sfree (lc);
63 } /* }}} void latency_counter_destroy */
65 void latency_counter_add (latency_counter_t *lc, cdtime_t latency) /* {{{ */
66 {
67   size_t latency_ms;
69   if ((lc == NULL) || (latency == 0))
70     return;
72   lc->sum += latency;
73   lc->num++;
75   if ((lc->min == 0) && (lc->max == 0))
76     lc->min = lc->max = latency;
77   if (lc->min > latency)
78     lc->min = latency;
79   if (lc->max < latency)
80     lc->max = latency;
82   /* A latency of _exactly_ 1.0 ms should be stored in the buffer 0, so
83    * subtract one from the cdtime_t value so that exactly 1.0 ms get sorted
84    * accordingly. */
85   latency_ms = (size_t) CDTIME_T_TO_MS (latency - 1);
86   if (latency_ms < STATIC_ARRAY_SIZE (lc->histogram))
87     lc->histogram[latency_ms]++;
88 } /* }}} void latency_counter_add */
90 void latency_counter_reset (latency_counter_t *lc) /* {{{ */
91 {
92   if (lc == NULL)
93     return;
95   memset (lc, 0, sizeof (*lc));
96   lc->start_time = cdtime ();
97 } /* }}} void latency_counter_reset */
99 cdtime_t latency_counter_get_min (latency_counter_t *lc) /* {{{ */
101   if (lc == NULL)
102     return (0);
103   return (lc->min);
104 } /* }}} cdtime_t latency_counter_get_min */
106 cdtime_t latency_counter_get_max (latency_counter_t *lc) /* {{{ */
108   if (lc == NULL)
109     return (0);
110   return (lc->max);
111 } /* }}} cdtime_t latency_counter_get_max */
113 cdtime_t latency_counter_get_average (latency_counter_t *lc) /* {{{ */
115   double average;
117   if (lc == NULL)
118     return (0);
120   average = CDTIME_T_TO_DOUBLE (lc->sum) / ((double) lc->num);
121   return (DOUBLE_TO_CDTIME_T (average));
122 } /* }}} cdtime_t latency_counter_get_average */
124 cdtime_t latency_counter_get_percentile (latency_counter_t *lc,
125     double percent)
127   double percent_upper;
128   double percent_lower;
129   double ms_upper;
130   double ms_lower;
131   double ms_interpolated;
132   int sum;
133   size_t i;
135   if ((lc == NULL) || !((percent > 0.0) && (percent < 100.0)))
136     return (0);
138   /* Find index i so that at least "percent" events are within i+1 ms. */
139   percent_upper = 0.0;
140   percent_lower = 0.0;
141   sum = 0;
142   for (i = 0; i < LATENCY_HISTOGRAM_SIZE; i++)
143   {
144     percent_lower = percent_upper;
145     sum += lc->histogram[i];
146     if (sum == 0)
147       percent_upper = 0.0;
148     else
149       percent_upper = 100.0 * ((double) sum) / ((double) lc->num);
151     if (percent_upper >= percent)
152       break;
153   }
155   if (i >= LATENCY_HISTOGRAM_SIZE)
156     return (0);
158   assert (percent_upper >= percent);
159   assert (percent_lower < percent);
161   ms_upper = (double) (i + 1);
162   ms_lower = (double) i;
163   if (i == 0)
164     return (MS_TO_CDTIME_T (ms_upper));
166   ms_interpolated = (((percent_upper - percent) * ms_lower)
167       + ((percent - percent_lower) * ms_upper))
168     / (percent_upper - percent_lower);
170   return (MS_TO_CDTIME_T (ms_interpolated));
171 } /* }}} cdtime_t latency_counter_get_percentile */
173 /* vim: set sw=2 sts=2 et fdm=marker : */