Merge branch 'collectd-5.3' into collectd-5.4
[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  **/
26
27 #include "collectd.h"
28 #include "utils_latency.h"
29 #include "common.h"
30
31 #ifndef LATENCY_HISTOGRAM_SIZE
32 # define LATENCY_HISTOGRAM_SIZE 1000
33 #endif
34
35 struct latency_counter_s
36 {
37   cdtime_t start_time;
38
39   cdtime_t sum;
40   size_t num;
41
42   cdtime_t min;
43   cdtime_t max;
44
45   int histogram[LATENCY_HISTOGRAM_SIZE];
46 };
47
48 latency_counter_t *latency_counter_create () /* {{{ */
49 {
50   latency_counter_t *lc;
51
52   lc = malloc (sizeof (*lc));
53   if (lc == NULL)
54     return (NULL);
55
56   latency_counter_reset (lc);
57   return (lc);
58 } /* }}} latency_counter_t *latency_counter_create */
59
60 void latency_counter_destroy (latency_counter_t *lc) /* {{{ */
61 {
62   sfree (lc);
63 } /* }}} void latency_counter_destroy */
64
65 void latency_counter_add (latency_counter_t *lc, cdtime_t latency) /* {{{ */
66 {
67   size_t latency_ms;
68
69   if ((lc == NULL) || (latency == 0))
70     return;
71
72   lc->sum += latency;
73   lc->num++;
74
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;
81
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 */
89
90 void latency_counter_reset (latency_counter_t *lc) /* {{{ */
91 {
92   if (lc == NULL)
93     return;
94
95   memset (lc, 0, sizeof (*lc));
96   lc->start_time = cdtime ();
97 } /* }}} void latency_counter_reset */
98
99 cdtime_t latency_counter_get_min (latency_counter_t *lc) /* {{{ */
100 {
101   if (lc == NULL)
102     return (0);
103   return (lc->min);
104 } /* }}} cdtime_t latency_counter_get_min */
105
106 cdtime_t latency_counter_get_max (latency_counter_t *lc) /* {{{ */
107 {
108   if (lc == NULL)
109     return (0);
110   return (lc->max);
111 } /* }}} cdtime_t latency_counter_get_max */
112
113 cdtime_t latency_counter_get_sum (latency_counter_t *lc) /* {{{ */
114 {
115   if (lc == NULL)
116     return (0);
117   return (lc->sum);
118 } /* }}} cdtime_t latency_counter_get_sum */
119
120 size_t latency_counter_get_num (latency_counter_t *lc) /* {{{ */
121 {
122   if (lc == NULL)
123     return (0);
124   return (lc->num);
125 } /* }}} size_t latency_counter_get_num */
126
127 cdtime_t latency_counter_get_average (latency_counter_t *lc) /* {{{ */
128 {
129   double average;
130
131   if (lc == NULL)
132     return (0);
133
134   average = CDTIME_T_TO_DOUBLE (lc->sum) / ((double) lc->num);
135   return (DOUBLE_TO_CDTIME_T (average));
136 } /* }}} cdtime_t latency_counter_get_average */
137
138 cdtime_t latency_counter_get_percentile (latency_counter_t *lc,
139     double percent)
140 {
141   double percent_upper;
142   double percent_lower;
143   double ms_upper;
144   double ms_lower;
145   double ms_interpolated;
146   int sum;
147   size_t i;
148
149   if ((lc == NULL) || !((percent > 0.0) && (percent < 100.0)))
150     return (0);
151
152   /* Find index i so that at least "percent" events are within i+1 ms. */
153   percent_upper = 0.0;
154   percent_lower = 0.0;
155   sum = 0;
156   for (i = 0; i < LATENCY_HISTOGRAM_SIZE; i++)
157   {
158     percent_lower = percent_upper;
159     sum += lc->histogram[i];
160     if (sum == 0)
161       percent_upper = 0.0;
162     else
163       percent_upper = 100.0 * ((double) sum) / ((double) lc->num);
164
165     if (percent_upper >= percent)
166       break;
167   }
168
169   if (i >= LATENCY_HISTOGRAM_SIZE)
170     return (0);
171
172   assert (percent_upper >= percent);
173   assert (percent_lower < percent);
174
175   ms_upper = (double) (i + 1);
176   ms_lower = (double) i;
177   if (i == 0)
178     return (MS_TO_CDTIME_T (ms_upper));
179
180   ms_interpolated = (((percent_upper - percent) * ms_lower)
181       + ((percent - percent_lower) * ms_upper))
182     / (percent_upper - percent_lower);
183
184   return (MS_TO_CDTIME_T (ms_interpolated));
185 } /* }}} cdtime_t latency_counter_get_percentile */
186
187 /* vim: set sw=2 sts=2 et fdm=marker : */