FD.io VPP  v17.04-9-g99c0734
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 /** \file
44 
45  Optimized thread-safe counters.
46 
47  Each vlib_[simple|combined]_counter_main_t consists of a per-thread
48  vector of per-object counters.
49 
50  The idea is to drastically eliminate atomic operations.
51 */
52 
53 /** 64bit counters */
54 typedef u64 counter_t;
55 
56 /** A collection of simple counters */
57 
58 typedef struct
59 {
60  counter_t **counters; /**< Per-thread u64 non-atomic counters */
61  counter_t *value_at_last_serialize; /**< Values as of last serialize. */
62  u32 last_incremental_serialize_index; /**< Last counter index
63  serialized incrementally. */
64 
65  char *name; /**< The counter collection's name. */
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 cpu_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 cpu_index, u32 index, u64 increment)
80 {
81  counter_t *my_counters;
82 
83  my_counters = cm->counters[cpu_index];
84  my_counters[index] += increment;
85 }
86 
87 /** Get the value of a simple counter
88  Scrapes the entire set of per-thread counters. Innacurate unless
89  worker threads which might increment the counter are
90  barrier-synchronized
91 
92  @param cm - (vlib_simple_counter_main_t *) simple counter main pointer
93  @param index - (u32) index of the counter to fetch
94  @returns - (u64) current counter value
95 */
98 {
99  counter_t *my_counters;
100  counter_t v;
101  int i;
102 
103  ASSERT (index < vlib_simple_counter_n_counters (cm));
104 
105  v = 0;
106 
107  for (i = 0; i < vec_len (cm->counters); i++)
108  {
109  my_counters = cm->counters[i];
110  v += my_counters[index];
111  }
112 
113  return v;
114 }
115 
116 /** Clear a simple counter
117  Clears the set of per-thread u16 counters, and the u64 counter
118 
119  @param cm - (vlib_simple_counter_main_t *) simple counter main pointer
120  @param index - (u32) index of the counter to clear
121 */
122 always_inline void
124 {
125  counter_t *my_counters;
126  int i;
127 
128  ASSERT (index < vlib_simple_counter_n_counters (cm));
129 
130  for (i = 0; i < vec_len (cm->counters); i++)
131  {
132  my_counters = cm->counters[i];
133  my_counters[index] = 0;
134  }
135 }
136 
137 /** Combined counter to hold both packets and byte differences.
138  */
139 typedef struct
140 {
141  counter_t packets; /**< packet counter */
142  counter_t bytes; /**< byte counter */
144 
145 /** Add two combined counters, results in the first counter
146  @param [in,out] a - (vlib_counter_t *) dst counter
147  @param b - (vlib_counter_t *) src counter
148 */
149 
150 always_inline void
152 {
153  a->packets += b->packets;
154  a->bytes += b->bytes;
155 }
156 
157 /** Subtract combined counters, results in the first counter
158  @param [in,out] a - (vlib_counter_t *) dst counter
159  @param b - (vlib_counter_t *) src counter
160 */
161 always_inline void
163 {
164  ASSERT (a->packets >= b->packets);
165  ASSERT (a->bytes >= b->bytes);
166  a->packets -= b->packets;
167  a->bytes -= b->bytes;
168 }
169 
170 /** Clear a combined counter
171  @param a - (vlib_counter_t *) counter to clear
172 */
173 always_inline void
175 {
176  a->packets = a->bytes = 0;
177 }
178 
179 /** A collection of combined counters */
180 typedef struct
181 {
182  vlib_counter_t **counters; /**< Per-thread u64 non-atomic counter pairs */
183  vlib_counter_t *value_at_last_serialize; /**< Counter values as of last serialize. */
184  u32 last_incremental_serialize_index; /**< Last counter index serialized incrementally. */
185  char *name; /**< The counter collection's name. */
187 
188 /** The number of counters (not the number of per-thread counters) */
190  cm);
191 
192 /** Clear a collection of simple counters
193  @param cm - (vlib_simple_counter_main_t *) collection to clear
194 */
196 
197 /** Clear a collection of combined counters
198  @param cm - (vlib_combined_counter_main_t *) collection to clear
199 */
201 
202 /** Increment a combined counter
203  @param cm - (vlib_combined_counter_main_t *) comined counter main pointer
204  @param cpu_index - (u32) the current cpu index
205  @param index - (u32) index of the counter to increment
206  @param packet_increment - (u64) number of packets to add to the counter
207  @param byte_increment - (u64) number of bytes to add to the counter
208 */
209 
210 always_inline void
212  u32 cpu_index,
213  u32 index, u64 n_packets, u64 n_bytes)
214 {
215  vlib_counter_t *my_counters;
216 
217  /* Use this CPU's counter array */
218  my_counters = cm->counters[cpu_index];
219 
220  my_counters[index].packets += n_packets;
221  my_counters[index].bytes += n_bytes;
222 }
223 
224 /** Pre-fetch a per-thread combined counter for the given object index */
225 always_inline void
227  u32 cpu_index, u32 index)
228 {
229  vlib_counter_t *cpu_counters;
230 
231  /*
232  * This CPU's index is assumed to already be in cache
233  */
234  cpu_counters = cm->counters[cpu_index];
235  CLIB_PREFETCH (cpu_counters + index, CLIB_CACHE_LINE_BYTES, STORE);
236 }
237 
238 
239 /** Get the value of a combined counter, never called in the speed path
240  Scrapes the entire set of per-thread counters. Innacurate unless
241  worker threads which might increment the counter are
242  barrier-synchronized
243 
244  @param cm - (vlib_combined_counter_main_t *) combined counter main pointer
245  @param index - (u32) index of the combined counter to fetch
246  @param result [out] - (vlib_counter_t *) result stored here
247 */
248 
249 static inline void
251  u32 index, vlib_counter_t * result)
252 {
253  vlib_counter_t *my_counters, *counter;
254  int i;
255 
256  result->packets = 0;
257  result->bytes = 0;
258 
259  for (i = 0; i < vec_len (cm->counters); i++)
260  {
261  my_counters = cm->counters[i];
262 
263  counter = vec_elt_at_index (my_counters, index);
264  result->packets += counter->packets;
265  result->bytes += counter->bytes;
266  }
267 }
268 
269 /** Clear a combined counter
270  Clears the set of per-thread counters.
271 
272  @param cm - (vlib_combined_counter_main_t *) combined counter main pointer
273  @param index - (u32) index of the counter to clear
274 */
275 always_inline void
277 {
278  vlib_counter_t *my_counters, *counter;
279  int i;
280 
281  for (i = 0; i < vec_len (cm->counters); i++)
282  {
283  my_counters = cm->counters[i];
284 
285  counter = vec_elt_at_index (my_counters, index);
286  counter->packets = 0;
287  counter->bytes = 0;
288  }
289 }
290 
291 /** validate a simple counter
292  @param cm - (vlib_simple_counter_main_t *) pointer to the counter collection
293  @param index - (u32) index of the counter to validate
294 */
295 
297  u32 index);
298 /** validate a combined counter
299  @param cm - (vlib_combined_counter_main_t *) pointer to the counter
300  collection
301  @param index - (u32) index of the counter to validate
302 */
303 
305  u32 index);
306 
307 /** Obtain the number of simple or combined counters allocated.
308  A macro which reduces to to vec_len(cm->maxi), the answer in either
309  case.
310 
311  @param cm - (vlib_simple_counter_main_t) or
312  (vlib_combined_counter_main_t) the counter collection to interrogate
313  @returns vec_len(cm->maxi)
314 */
315 #define vlib_counter_len(cm) vec_len((cm)->maxi)
316 
321 
322 #endif /* included_vlib_counter_h */
323 
324 /*
325  * fd.io coding-style-patch-verification: ON
326  *
327  * Local Variables:
328  * eval: (c-set-style "gnu")
329  * End:
330  */
sll srl srl sll sra u16x4 i
Definition: vector_sse2.h:343
void vlib_clear_combined_counters(vlib_combined_counter_main_t *cm)
Clear a collection of combined counters.
Definition: counter.c:60
a
Definition: bitmap.h:516
void vlib_validate_simple_counter(vlib_simple_counter_main_t *cm, u32 index)
validate a simple counter
Definition: counter.c:78
vlib_counter_t * value_at_last_serialize
Counter values as of last serialize.
Definition: counter.h:183
Combined counter to hold both packets and byte differences.
Definition: counter.h:139
static void vlib_counter_zero(vlib_counter_t *a)
Clear a combined counter.
Definition: counter.h:174
static void vlib_prefetch_combined_counter(const vlib_combined_counter_main_t *cm, u32 cpu_index, u32 index)
Pre-fetch a per-thread combined counter for the given object index.
Definition: counter.h:226
vlib_counter_t ** counters
Per-thread u64 non-atomic counter pairs.
Definition: counter.h:182
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:97
#define always_inline
Definition: clib.h:84
#define vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
unsigned long u64
Definition: types.h:89
static void vlib_counter_sub(vlib_counter_t *a, vlib_counter_t *b)
Subtract combined counters, results in the first counter.
Definition: counter.h:162
A collection of simple counters.
Definition: counter.h:58
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:151
char * name
The counter collection&#39;s name.
Definition: counter.h:65
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:276
counter_t packets
packet counter
Definition: counter.h:141
serialize_function_t unserialize_vlib_simple_counter_main
Definition: counter.h:317
#define v
Definition: acl.c:246
u32 last_incremental_serialize_index
Last counter index serialized incrementally.
Definition: counter.h:184
counter_t * value_at_last_serialize
Values as of last serialize.
Definition: counter.h:61
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:250
#define CLIB_PREFETCH(addr, size, type)
Definition: cache.h:82
serialize_function_t serialize_vlib_combined_counter_main
Definition: counter.h:319
u32 last_incremental_serialize_index
Last counter index serialized incrementally.
Definition: counter.h:62
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:107
void vlib_validate_combined_counter(vlib_combined_counter_main_t *cm, u32 index)
validate a combined counter
Definition: counter.c:89
serialize_function_t serialize_vlib_simple_counter_main
Definition: counter.h:317
#define ASSERT(truth)
unsigned int u32
Definition: types.h:88
static void vlib_increment_combined_counter(vlib_combined_counter_main_t *cm, u32 cpu_index, u32 index, u64 n_packets, u64 n_bytes)
Increment a combined counter.
Definition: counter.h:211
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:100
serialize_function_t unserialize_vlib_combined_counter_main
Definition: counter.h:319
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:123
u64 counter_t
64bit counters
Definition: counter.h:54
counter_t bytes
byte counter
Definition: counter.h:142
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
void( serialize_function_t)(serialize_main_t *m, va_list *va)
Definition: serialize.h:168
char * name
The counter collection&#39;s name.
Definition: counter.h:185
A collection of combined counters.
Definition: counter.h:180
counter_t ** counters
Per-thread u64 non-atomic counters.
Definition: counter.h:60
void vlib_clear_simple_counters(vlib_simple_counter_main_t *cm)
Clear a collection of simple counters.
Definition: counter.c:43
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:67
static void vlib_increment_simple_counter(vlib_simple_counter_main_t *cm, u32 cpu_index, u32 index, u64 increment)
Increment a simple counter.
Definition: counter.h:78