FD.io VPP  v19.08.3-2-gbabecb413
Vector Packet Processing
counter.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2015 Cisco and/or its affiliates.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at:
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 /*
16  * counter.h: simple and packet/byte counters
17  *
18  * Copyright (c) 2008 Eliot Dresselhaus
19  *
20  * Permission is hereby granted, free of charge, to any person obtaining
21  * a copy of this software and associated documentation files (the
22  * "Software"), to deal in the Software without restriction, including
23  * without limitation the rights to use, copy, modify, merge, publish,
24  * distribute, sublicense, and/or sell copies of the Software, and to
25  * permit persons to whom the Software is furnished to do so, subject to
26  * the following conditions:
27  *
28  * The above copyright notice and this permission notice shall be
29  * included in all copies or substantial portions of the Software.
30  *
31  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
32  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
33  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
34  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
35  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
36  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
37  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
38  */
39 
40 #ifndef included_vlib_counter_h
41 #define included_vlib_counter_h
42 
43 #include <vlib/counter_types.h>
44 
45 /** \file
46 
47  Optimized thread-safe counters.
48 
49  Each vlib_[simple|combined]_counter_main_t consists of a per-thread
50  vector of per-object counters.
51 
52  The idea is to drastically eliminate atomic operations.
53 */
54 
55 /** A collection of simple counters */
56 
57 typedef struct
58 {
59  counter_t **counters; /**< Per-thread u64 non-atomic counters */
60  counter_t *value_at_last_serialize; /**< Values as of last serialize. */
61  u32 last_incremental_serialize_index; /**< Last counter index
62  serialized incrementally. */
63 
64  char *name; /**< The counter collection's name. */
65  char *stat_segment_name; /**< Name in stat segment directory */
67 
68 /** The number of counters (not the number of per-thread counters) */
70 
71 /** Increment a simple counter
72  @param cm - (vlib_simple_counter_main_t *) simple counter main pointer
73  @param thread_index - (u32) the current cpu index
74  @param index - (u32) index of the counter to increment
75  @param increment - (u64) quantitiy to add to the counter
76 */
77 always_inline void
79  u32 thread_index, u32 index, u64 increment)
80 {
81  counter_t *my_counters;
82 
83  my_counters = cm->counters[thread_index];
84  my_counters[index] += increment;
85 }
86 
87 /** Set a simple counter
88  @param cm - (vlib_simple_counter_main_t *) simple counter main pointer
89  @param thread_index - (u32) the current cpu index
90  @param index - (u32) index of the counter to increment
91  @param value - (u64) quantitiy to set to the counter
92 */
93 always_inline void
95  u32 thread_index, u32 index, u64 value)
96 {
97  counter_t *my_counters;
98 
99  my_counters = cm->counters[thread_index];
100  my_counters[index] = value;
101 }
102 
103 /** Get the value of a simple counter
104  Scrapes the entire set of per-thread counters. Innacurate unless
105  worker threads which might increment the counter are
106  barrier-synchronized
107 
108  @param cm - (vlib_simple_counter_main_t *) simple counter main pointer
109  @param index - (u32) index of the counter to fetch
110  @returns - (u64) current counter value
111 */
114 {
115  counter_t *my_counters;
116  counter_t v;
117  int i;
118 
119  ASSERT (index < vlib_simple_counter_n_counters (cm));
120 
121  v = 0;
122 
123  for (i = 0; i < vec_len (cm->counters); i++)
124  {
125  my_counters = cm->counters[i];
126  v += my_counters[index];
127  }
128 
129  return v;
130 }
131 
132 /** Clear a simple counter
133  Clears the set of per-thread u16 counters, and the u64 counter
134 
135  @param cm - (vlib_simple_counter_main_t *) simple counter main pointer
136  @param index - (u32) index of the counter to clear
137 */
138 always_inline void
140 {
141  counter_t *my_counters;
142  int i;
143 
144  ASSERT (index < vlib_simple_counter_n_counters (cm));
145 
146  for (i = 0; i < vec_len (cm->counters); i++)
147  {
148  my_counters = cm->counters[i];
149  my_counters[index] = 0;
150  }
151 }
152 
153 /** Add two combined counters, results in the first counter
154  @param [in,out] a - (vlib_counter_t *) dst counter
155  @param b - (vlib_counter_t *) src counter
156 */
157 
158 always_inline void
160 {
161  a->packets += b->packets;
162  a->bytes += b->bytes;
163 }
164 
165 /** Subtract combined counters, results in the first counter
166  @param [in,out] a - (vlib_counter_t *) dst counter
167  @param b - (vlib_counter_t *) src counter
168 */
169 always_inline void
171 {
172  ASSERT (a->packets >= b->packets);
173  ASSERT (a->bytes >= b->bytes);
174  a->packets -= b->packets;
175  a->bytes -= b->bytes;
176 }
177 
178 /** Clear a combined counter
179  @param a - (vlib_counter_t *) counter to clear
180 */
181 always_inline void
183 {
184  a->packets = a->bytes = 0;
185 }
186 
187 /** A collection of combined counters */
188 typedef struct
189 {
190  vlib_counter_t **counters; /**< Per-thread u64 non-atomic counter pairs */
191  vlib_counter_t *value_at_last_serialize; /**< Counter values as of last serialize. */
192  u32 last_incremental_serialize_index; /**< Last counter index serialized incrementally. */
193  char *name; /**< The counter collection's name. */
194  char *stat_segment_name; /**< Name in stat segment directory */
196 
197 /** The number of counters (not the number of per-thread counters) */
199  cm);
200 
201 /** Clear a collection of simple counters
202  @param cm - (vlib_simple_counter_main_t *) collection to clear
203 */
205 
206 /** Clear a collection of combined counters
207  @param cm - (vlib_combined_counter_main_t *) collection to clear
208 */
210 
211 /** Increment a combined counter
212  @param cm - (vlib_combined_counter_main_t *) comined counter main pointer
213  @param thread_index - (u32) the current cpu index
214  @param index - (u32) index of the counter to increment
215  @param packet_increment - (u64) number of packets to add to the counter
216  @param byte_increment - (u64) number of bytes to add to the counter
217 */
218 
219 always_inline void
221  u32 thread_index,
222  u32 index, u64 n_packets, u64 n_bytes)
223 {
224  vlib_counter_t *my_counters;
225 
226  /* Use this CPU's counter array */
227  my_counters = cm->counters[thread_index];
228 
229  my_counters[index].packets += n_packets;
230  my_counters[index].bytes += n_bytes;
231 }
232 
233 /** Pre-fetch a per-thread combined counter for the given object index */
234 always_inline void
236  u32 thread_index, u32 index)
237 {
238  vlib_counter_t *cpu_counters;
239 
240  /*
241  * This CPU's index is assumed to already be in cache
242  */
243  cpu_counters = cm->counters[thread_index];
244  CLIB_PREFETCH (cpu_counters + index, CLIB_CACHE_LINE_BYTES, STORE);
245 }
246 
247 
248 /** Get the value of a combined counter, never called in the speed path
249  Scrapes the entire set of per-thread counters. Innacurate unless
250  worker threads which might increment the counter are
251  barrier-synchronized
252 
253  @param cm - (vlib_combined_counter_main_t *) combined counter main pointer
254  @param index - (u32) index of the combined counter to fetch
255  @param result [out] - (vlib_counter_t *) result stored here
256 */
257 
258 static inline void
260  u32 index, vlib_counter_t * result)
261 {
262  vlib_counter_t *my_counters, *counter;
263  int i;
264 
265  result->packets = 0;
266  result->bytes = 0;
267 
268  for (i = 0; i < vec_len (cm->counters); i++)
269  {
270  my_counters = cm->counters[i];
271 
272  counter = vec_elt_at_index (my_counters, index);
273  result->packets += counter->packets;
274  result->bytes += counter->bytes;
275  }
276 }
277 
278 /** Clear a combined counter
279  Clears the set of per-thread counters.
280 
281  @param cm - (vlib_combined_counter_main_t *) combined counter main pointer
282  @param index - (u32) index of the counter to clear
283 */
284 always_inline void
286 {
287  vlib_counter_t *my_counters, *counter;
288  int i;
289 
290  for (i = 0; i < vec_len (cm->counters); i++)
291  {
292  my_counters = cm->counters[i];
293 
294  counter = vec_elt_at_index (my_counters, index);
295  counter->packets = 0;
296  counter->bytes = 0;
297  }
298 }
299 
300 /** validate a simple counter
301  @param cm - (vlib_simple_counter_main_t *) pointer to the counter collection
302  @param index - (u32) index of the counter to validate
303 */
304 
306  u32 index);
308 
309 /** validate a combined counter
310  @param cm - (vlib_combined_counter_main_t *) pointer to the counter
311  collection
312  @param index - (u32) index of the counter to validate
313 */
314 
316  u32 index);
318  (vlib_combined_counter_main_t * cm, u32 index);
319 
321 
322 /** Obtain the number of simple or combined counters allocated.
323  A macro which reduces to to vec_len(cm->maxi), the answer in either
324  case.
325 
326  @param cm - (vlib_simple_counter_main_t) or
327  (vlib_combined_counter_main_t) the counter collection to interrogate
328  @returns vec_len(cm->maxi)
329 */
330 #define vlib_counter_len(cm) vec_len((cm)->maxi)
331 
336 
337 #endif /* included_vlib_counter_h */
338 
339 /*
340  * fd.io coding-style-patch-verification: ON
341  *
342  * Local Variables:
343  * eval: (c-set-style "gnu")
344  * End:
345  */
void vlib_clear_combined_counters(vlib_combined_counter_main_t *cm)
Clear a collection of combined counters.
Definition: counter.c:61
a
Definition: bitmap.h:538
void vlib_validate_simple_counter(vlib_simple_counter_main_t *cm, u32 index)
validate a simple counter
Definition: counter.c:79
static void vlib_increment_combined_counter(vlib_combined_counter_main_t *cm, u32 thread_index, u32 index, u64 n_packets, u64 n_bytes)
Increment a combined counter.
Definition: counter.h:220
char * stat_segment_name
Name in stat segment directory.
Definition: counter.h:194
vlib_counter_t * value_at_last_serialize
Counter values as of last serialize.
Definition: counter.h:191
unsigned long u64
Definition: types.h:89
Combined counter to hold both packets and byte differences.
Definition: counter_types.h:26
int i
void() serialize_function_t(serialize_main_t *m, va_list *va)
Definition: serialize.h:168
static void vlib_increment_simple_counter(vlib_simple_counter_main_t *cm, u32 thread_index, u32 index, u64 increment)
Increment a simple counter.
Definition: counter.h:78
static void vlib_counter_zero(vlib_counter_t *a)
Clear a combined counter.
Definition: counter.h:182
vlib_counter_t ** counters
Per-thread u64 non-atomic counter pairs.
Definition: counter.h:190
static counter_t vlib_get_simple_counter(vlib_simple_counter_main_t *cm, u32 index)
Get the value of a simple counter Scrapes the entire set of per-thread counters.
Definition: counter.h:113
#define always_inline
Definition: clib.h:99
uint64_t counter_t
64bit counters
Definition: counter_types.h:22
#define vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
unsigned int u32
Definition: types.h:88
static void vlib_counter_sub(vlib_counter_t *a, vlib_counter_t *b)
Subtract combined counters, results in the first counter.
Definition: counter.h:170
A collection of simple counters.
Definition: counter.h:57
static void vlib_counter_add(vlib_counter_t *a, vlib_counter_t *b)
Add two combined counters, results in the first counter.
Definition: counter.h:159
void vlib_free_combined_counter(vlib_combined_counter_main_t *cm)
Definition: counter.c:161
char * name
The counter collection&#39;s name.
Definition: counter.h:64
static void vlib_zero_combined_counter(vlib_combined_counter_main_t *cm, u32 index)
Clear a combined counter Clears the set of per-thread counters.
Definition: counter.h:285
counter_t packets
packet counter
Definition: counter_types.h:28
serialize_function_t unserialize_vlib_simple_counter_main
Definition: counter.h:332
static void vlib_prefetch_combined_counter(const vlib_combined_counter_main_t *cm, u32 thread_index, u32 index)
Pre-fetch a per-thread combined counter for the given object index.
Definition: counter.h:235
static void vlib_set_simple_counter(vlib_simple_counter_main_t *cm, u32 thread_index, u32 index, u64 value)
Set a simple counter.
Definition: counter.h:94
u32 last_incremental_serialize_index
Last counter index serialized incrementally.
Definition: counter.h:192
counter_t * value_at_last_serialize
Values as of last serialize.
Definition: counter.h:60
static void vlib_get_combined_counter(const vlib_combined_counter_main_t *cm, u32 index, vlib_counter_t *result)
Get the value of a combined counter, never called in the speed path Scrapes the entire set of per-thr...
Definition: counter.h:259
#define CLIB_PREFETCH(addr, size, type)
Definition: cache.h:80
serialize_function_t serialize_vlib_combined_counter_main
Definition: counter.h:334
u32 last_incremental_serialize_index
Last counter index serialized incrementally.
Definition: counter.h:61
void vlib_free_simple_counter(vlib_simple_counter_main_t *cm)
Definition: counter.c:94
u32 vlib_simple_counter_n_counters(const vlib_simple_counter_main_t *cm)
The number of counters (not the number of per-thread counters)
Definition: counter.c:182
void vlib_validate_combined_counter(vlib_combined_counter_main_t *cm, u32 index)
validate a combined counter
Definition: counter.c:108
serialize_function_t serialize_vlib_simple_counter_main
Definition: counter.h:332
u8 value
Definition: qos.api:53
#define ASSERT(truth)
u32 vlib_combined_counter_n_counters(const vlib_combined_counter_main_t *cm)
The number of counters (not the number of per-thread counters)
Definition: counter.c:175
serialize_function_t unserialize_vlib_combined_counter_main
Definition: counter.h:334
int vlib_validate_combined_counter_will_expand(vlib_combined_counter_main_t *cm, u32 index)
Definition: counter.c:124
static void vlib_zero_simple_counter(vlib_simple_counter_main_t *cm, u32 index)
Clear a simple counter Clears the set of per-thread u16 counters, and the u64 counter.
Definition: counter.h:139
counter_t bytes
byte counter
Definition: counter_types.h:29
char * stat_segment_name
Name in stat segment directory.
Definition: counter.h:65
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
char * name
The counter collection&#39;s name.
Definition: counter.h:193
A collection of combined counters.
Definition: counter.h:188
counter_t ** counters
Per-thread u64 non-atomic counters.
Definition: counter.h:59
void vlib_clear_simple_counters(vlib_simple_counter_main_t *cm)
Clear a collection of simple counters.
Definition: counter.c:44
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:59