Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 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 | |
Ole Troan | 58492a8 | 2018-09-04 13:19:12 +0200 | [diff] [blame] | 43 | #include <vlib/counter_types.h> |
| 44 | |
Dave Barach | 6353920 | 2016-08-11 17:21:02 -0400 | [diff] [blame] | 45 | /** \file |
| 46 | |
| 47 | Optimized thread-safe counters. |
| 48 | |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 49 | Each vlib_[simple|combined]_counter_main_t consists of a per-thread |
| 50 | vector of per-object counters. |
Dave Barach | 6353920 | 2016-08-11 17:21:02 -0400 | [diff] [blame] | 51 | |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 52 | The idea is to drastically eliminate atomic operations. |
Dave Barach | 6353920 | 2016-08-11 17:21:02 -0400 | [diff] [blame] | 53 | */ |
| 54 | |
| 55 | /** A collection of simple counters */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 56 | |
Dave Barach | 9b8ffd9 | 2016-07-08 08:13:45 -0400 | [diff] [blame] | 57 | typedef struct |
| 58 | { |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 59 | counter_t **counters; /**< Per-thread u64 non-atomic counters */ |
Dave Barach | 6353920 | 2016-08-11 17:21:02 -0400 | [diff] [blame] | 60 | char *name; /**< The counter collection's name. */ |
Dave Barach | 048a4e5 | 2018-06-01 18:52:25 -0400 | [diff] [blame] | 61 | char *stat_segment_name; /**< Name in stat segment directory */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 62 | } vlib_simple_counter_main_t; |
| 63 | |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 64 | /** The number of counters (not the number of per-thread counters) */ |
| 65 | u32 vlib_simple_counter_n_counters (const vlib_simple_counter_main_t * cm); |
| 66 | |
Neale Ranns | e11203e | 2021-09-21 12:34:19 +0000 | [diff] [blame^] | 67 | /** Pre-fetch a per-thread simple counter for the given object index */ |
| 68 | always_inline void |
| 69 | vlib_prefetch_simple_counter (const vlib_simple_counter_main_t *cm, |
| 70 | u32 thread_index, u32 index) |
| 71 | { |
| 72 | counter_t *my_counters; |
| 73 | |
| 74 | /* |
| 75 | * This CPU's index is assumed to already be in cache |
| 76 | */ |
| 77 | my_counters = cm->counters[thread_index]; |
| 78 | clib_prefetch_store (my_counters + index); |
| 79 | } |
| 80 | |
Dave Barach | 6353920 | 2016-08-11 17:21:02 -0400 | [diff] [blame] | 81 | /** Increment a simple counter |
| 82 | @param cm - (vlib_simple_counter_main_t *) simple counter main pointer |
Damjan Marion | 586afd7 | 2017-04-05 19:18:20 +0200 | [diff] [blame] | 83 | @param thread_index - (u32) the current cpu index |
Dave Barach | 6353920 | 2016-08-11 17:21:02 -0400 | [diff] [blame] | 84 | @param index - (u32) index of the counter to increment |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 85 | @param increment - (u64) quantitiy to add to the counter |
Dave Barach | 6353920 | 2016-08-11 17:21:02 -0400 | [diff] [blame] | 86 | */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 87 | always_inline void |
| 88 | vlib_increment_simple_counter (vlib_simple_counter_main_t * cm, |
Damjan Marion | 586afd7 | 2017-04-05 19:18:20 +0200 | [diff] [blame] | 89 | u32 thread_index, u32 index, u64 increment) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 90 | { |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 91 | counter_t *my_counters; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 92 | |
Damjan Marion | 586afd7 | 2017-04-05 19:18:20 +0200 | [diff] [blame] | 93 | my_counters = cm->counters[thread_index]; |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 94 | my_counters[index] += increment; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 95 | } |
| 96 | |
Sergey Matov | 34262d4 | 2020-09-15 13:40:55 +0400 | [diff] [blame] | 97 | /** Decrement a simple counter |
| 98 | @param cm - (vlib_simple_counter_main_t *) simple counter main pointer |
| 99 | @param thread_index - (u32) the current cpu index |
| 100 | @param index - (u32) index of the counter to increment |
| 101 | @param increment - (u64) quantitiy remove from the counter value |
| 102 | */ |
| 103 | always_inline void |
| 104 | vlib_decrement_simple_counter (vlib_simple_counter_main_t * cm, |
| 105 | u32 thread_index, u32 index, u64 decrement) |
| 106 | { |
| 107 | counter_t *my_counters; |
| 108 | |
| 109 | my_counters = cm->counters[thread_index]; |
| 110 | |
| 111 | ASSERT (my_counters[index] >= decrement); |
| 112 | |
| 113 | my_counters[index] -= decrement; |
| 114 | } |
| 115 | |
Matus Fabian | b0055c8 | 2018-12-17 05:29:28 -0800 | [diff] [blame] | 116 | /** Set a simple counter |
| 117 | @param cm - (vlib_simple_counter_main_t *) simple counter main pointer |
| 118 | @param thread_index - (u32) the current cpu index |
| 119 | @param index - (u32) index of the counter to increment |
| 120 | @param value - (u64) quantitiy to set to the counter |
| 121 | */ |
| 122 | always_inline void |
| 123 | vlib_set_simple_counter (vlib_simple_counter_main_t * cm, |
| 124 | u32 thread_index, u32 index, u64 value) |
| 125 | { |
| 126 | counter_t *my_counters; |
| 127 | |
| 128 | my_counters = cm->counters[thread_index]; |
| 129 | my_counters[index] = value; |
| 130 | } |
| 131 | |
Dave Barach | 6353920 | 2016-08-11 17:21:02 -0400 | [diff] [blame] | 132 | /** Get the value of a simple counter |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 133 | Scrapes the entire set of per-thread counters. Innacurate unless |
Dave Barach | 6353920 | 2016-08-11 17:21:02 -0400 | [diff] [blame] | 134 | worker threads which might increment the counter are |
| 135 | barrier-synchronized |
| 136 | |
| 137 | @param cm - (vlib_simple_counter_main_t *) simple counter main pointer |
| 138 | @param index - (u32) index of the counter to fetch |
| 139 | @returns - (u64) current counter value |
| 140 | */ |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 141 | always_inline counter_t |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 142 | vlib_get_simple_counter (vlib_simple_counter_main_t * cm, u32 index) |
| 143 | { |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 144 | counter_t *my_counters; |
| 145 | counter_t v; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 146 | int i; |
| 147 | |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 148 | ASSERT (index < vlib_simple_counter_n_counters (cm)); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 149 | |
| 150 | v = 0; |
| 151 | |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 152 | for (i = 0; i < vec_len (cm->counters); i++) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 153 | { |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 154 | my_counters = cm->counters[i]; |
| 155 | v += my_counters[index]; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 156 | } |
| 157 | |
| 158 | return v; |
| 159 | } |
| 160 | |
Dave Barach | 6353920 | 2016-08-11 17:21:02 -0400 | [diff] [blame] | 161 | /** Clear a simple counter |
| 162 | Clears the set of per-thread u16 counters, and the u64 counter |
| 163 | |
| 164 | @param cm - (vlib_simple_counter_main_t *) simple counter main pointer |
| 165 | @param index - (u32) index of the counter to clear |
| 166 | */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 167 | always_inline void |
| 168 | vlib_zero_simple_counter (vlib_simple_counter_main_t * cm, u32 index) |
| 169 | { |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 170 | counter_t *my_counters; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 171 | int i; |
| 172 | |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 173 | ASSERT (index < vlib_simple_counter_n_counters (cm)); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 174 | |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 175 | for (i = 0; i < vec_len (cm->counters); i++) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 176 | { |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 177 | my_counters = cm->counters[i]; |
| 178 | my_counters[index] = 0; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 179 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 180 | } |
| 181 | |
Dave Barach | 6353920 | 2016-08-11 17:21:02 -0400 | [diff] [blame] | 182 | /** Add two combined counters, results in the first counter |
Chris Luke | d4024f5 | 2016-09-06 09:32:36 -0400 | [diff] [blame] | 183 | @param [in,out] a - (vlib_counter_t *) dst counter |
Dave Barach | 6353920 | 2016-08-11 17:21:02 -0400 | [diff] [blame] | 184 | @param b - (vlib_counter_t *) src counter |
| 185 | */ |
| 186 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 187 | always_inline void |
| 188 | vlib_counter_add (vlib_counter_t * a, vlib_counter_t * b) |
| 189 | { |
| 190 | a->packets += b->packets; |
| 191 | a->bytes += b->bytes; |
| 192 | } |
| 193 | |
Dave Barach | 6353920 | 2016-08-11 17:21:02 -0400 | [diff] [blame] | 194 | /** Subtract combined counters, results in the first counter |
Chris Luke | d4024f5 | 2016-09-06 09:32:36 -0400 | [diff] [blame] | 195 | @param [in,out] a - (vlib_counter_t *) dst counter |
Dave Barach | 6353920 | 2016-08-11 17:21:02 -0400 | [diff] [blame] | 196 | @param b - (vlib_counter_t *) src counter |
| 197 | */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 198 | always_inline void |
| 199 | vlib_counter_sub (vlib_counter_t * a, vlib_counter_t * b) |
| 200 | { |
| 201 | ASSERT (a->packets >= b->packets); |
| 202 | ASSERT (a->bytes >= b->bytes); |
| 203 | a->packets -= b->packets; |
| 204 | a->bytes -= b->bytes; |
| 205 | } |
| 206 | |
Dave Barach | 6353920 | 2016-08-11 17:21:02 -0400 | [diff] [blame] | 207 | /** Clear a combined counter |
| 208 | @param a - (vlib_counter_t *) counter to clear |
| 209 | */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 210 | always_inline void |
| 211 | vlib_counter_zero (vlib_counter_t * a) |
Dave Barach | 9b8ffd9 | 2016-07-08 08:13:45 -0400 | [diff] [blame] | 212 | { |
| 213 | a->packets = a->bytes = 0; |
| 214 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 215 | |
Dave Barach | 6353920 | 2016-08-11 17:21:02 -0400 | [diff] [blame] | 216 | /** A collection of combined counters */ |
Dave Barach | 9b8ffd9 | 2016-07-08 08:13:45 -0400 | [diff] [blame] | 217 | typedef struct |
| 218 | { |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 219 | vlib_counter_t **counters; /**< Per-thread u64 non-atomic counter pairs */ |
Dave Barach | 6353920 | 2016-08-11 17:21:02 -0400 | [diff] [blame] | 220 | char *name; /**< The counter collection's name. */ |
Dave Barach | 048a4e5 | 2018-06-01 18:52:25 -0400 | [diff] [blame] | 221 | char *stat_segment_name; /**< Name in stat segment directory */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 222 | } vlib_combined_counter_main_t; |
| 223 | |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 224 | /** The number of counters (not the number of per-thread counters) */ |
| 225 | u32 vlib_combined_counter_n_counters (const vlib_combined_counter_main_t * |
| 226 | cm); |
| 227 | |
Dave Barach | 6353920 | 2016-08-11 17:21:02 -0400 | [diff] [blame] | 228 | /** Clear a collection of simple counters |
| 229 | @param cm - (vlib_simple_counter_main_t *) collection to clear |
| 230 | */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 231 | void vlib_clear_simple_counters (vlib_simple_counter_main_t * cm); |
Dave Barach | 6353920 | 2016-08-11 17:21:02 -0400 | [diff] [blame] | 232 | |
| 233 | /** Clear a collection of combined counters |
| 234 | @param cm - (vlib_combined_counter_main_t *) collection to clear |
| 235 | */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 236 | void vlib_clear_combined_counters (vlib_combined_counter_main_t * cm); |
| 237 | |
Dave Barach | 6353920 | 2016-08-11 17:21:02 -0400 | [diff] [blame] | 238 | /** Increment a combined counter |
| 239 | @param cm - (vlib_combined_counter_main_t *) comined counter main pointer |
Damjan Marion | 586afd7 | 2017-04-05 19:18:20 +0200 | [diff] [blame] | 240 | @param thread_index - (u32) the current cpu index |
Dave Barach | 6353920 | 2016-08-11 17:21:02 -0400 | [diff] [blame] | 241 | @param index - (u32) index of the counter to increment |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 242 | @param packet_increment - (u64) number of packets to add to the counter |
| 243 | @param byte_increment - (u64) number of bytes to add to the counter |
Dave Barach | 6353920 | 2016-08-11 17:21:02 -0400 | [diff] [blame] | 244 | */ |
| 245 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 246 | always_inline void |
| 247 | vlib_increment_combined_counter (vlib_combined_counter_main_t * cm, |
Damjan Marion | 586afd7 | 2017-04-05 19:18:20 +0200 | [diff] [blame] | 248 | u32 thread_index, |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 249 | u32 index, u64 n_packets, u64 n_bytes) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 250 | { |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 251 | vlib_counter_t *my_counters; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 252 | |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 253 | /* Use this CPU's counter array */ |
Damjan Marion | 586afd7 | 2017-04-05 19:18:20 +0200 | [diff] [blame] | 254 | my_counters = cm->counters[thread_index]; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 255 | |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 256 | my_counters[index].packets += n_packets; |
| 257 | my_counters[index].bytes += n_bytes; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 258 | } |
| 259 | |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 260 | /** Pre-fetch a per-thread combined counter for the given object index */ |
| 261 | always_inline void |
| 262 | vlib_prefetch_combined_counter (const vlib_combined_counter_main_t * cm, |
Damjan Marion | 586afd7 | 2017-04-05 19:18:20 +0200 | [diff] [blame] | 263 | u32 thread_index, u32 index) |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 264 | { |
| 265 | vlib_counter_t *cpu_counters; |
| 266 | |
| 267 | /* |
| 268 | * This CPU's index is assumed to already be in cache |
| 269 | */ |
Damjan Marion | 586afd7 | 2017-04-05 19:18:20 +0200 | [diff] [blame] | 270 | cpu_counters = cm->counters[thread_index]; |
Damjan Marion | af7fb04 | 2021-07-15 11:54:41 +0200 | [diff] [blame] | 271 | clib_prefetch_store (cpu_counters + index); |
Neale Ranns | 044183f | 2017-01-24 01:34:25 -0800 | [diff] [blame] | 272 | } |
| 273 | |
| 274 | |
Dave Barach | 6353920 | 2016-08-11 17:21:02 -0400 | [diff] [blame] | 275 | /** Get the value of a combined counter, never called in the speed path |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 276 | Scrapes the entire set of per-thread counters. Innacurate unless |
Dave Barach | 6353920 | 2016-08-11 17:21:02 -0400 | [diff] [blame] | 277 | worker threads which might increment the counter are |
| 278 | barrier-synchronized |
| 279 | |
| 280 | @param cm - (vlib_combined_counter_main_t *) combined counter main pointer |
| 281 | @param index - (u32) index of the combined counter to fetch |
| 282 | @param result [out] - (vlib_counter_t *) result stored here |
| 283 | */ |
| 284 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 285 | static inline void |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 286 | vlib_get_combined_counter (const vlib_combined_counter_main_t * cm, |
Dave Barach | 9b8ffd9 | 2016-07-08 08:13:45 -0400 | [diff] [blame] | 287 | u32 index, vlib_counter_t * result) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 288 | { |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 289 | vlib_counter_t *my_counters, *counter; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 290 | int i; |
| 291 | |
| 292 | result->packets = 0; |
| 293 | result->bytes = 0; |
| 294 | |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 295 | for (i = 0; i < vec_len (cm->counters); i++) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 296 | { |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 297 | my_counters = cm->counters[i]; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 298 | |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 299 | counter = vec_elt_at_index (my_counters, index); |
| 300 | result->packets += counter->packets; |
| 301 | result->bytes += counter->bytes; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 302 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 303 | } |
| 304 | |
Dave Barach | 6353920 | 2016-08-11 17:21:02 -0400 | [diff] [blame] | 305 | /** Clear a combined counter |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 306 | Clears the set of per-thread counters. |
Dave Barach | 6353920 | 2016-08-11 17:21:02 -0400 | [diff] [blame] | 307 | |
| 308 | @param cm - (vlib_combined_counter_main_t *) combined counter main pointer |
| 309 | @param index - (u32) index of the counter to clear |
| 310 | */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 311 | always_inline void |
Dave Barach | 9b8ffd9 | 2016-07-08 08:13:45 -0400 | [diff] [blame] | 312 | vlib_zero_combined_counter (vlib_combined_counter_main_t * cm, u32 index) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 313 | { |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 314 | vlib_counter_t *my_counters, *counter; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 315 | int i; |
| 316 | |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 317 | for (i = 0; i < vec_len (cm->counters); i++) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 318 | { |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 319 | my_counters = cm->counters[i]; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 320 | |
Neale Ranns | 1bd0109 | 2017-03-15 15:41:17 -0400 | [diff] [blame] | 321 | counter = vec_elt_at_index (my_counters, index); |
| 322 | counter->packets = 0; |
| 323 | counter->bytes = 0; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 324 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 325 | } |
| 326 | |
Dave Barach | 6353920 | 2016-08-11 17:21:02 -0400 | [diff] [blame] | 327 | /** validate a simple counter |
| 328 | @param cm - (vlib_simple_counter_main_t *) pointer to the counter collection |
| 329 | @param index - (u32) index of the counter to validate |
| 330 | */ |
| 331 | |
Dave Barach | 9b8ffd9 | 2016-07-08 08:13:45 -0400 | [diff] [blame] | 332 | void vlib_validate_simple_counter (vlib_simple_counter_main_t * cm, |
| 333 | u32 index); |
Ole Troan | a568a19 | 2020-04-21 17:54:41 +0200 | [diff] [blame] | 334 | void vlib_free_simple_counter (vlib_simple_counter_main_t * cm); |
| 335 | |
Dave Barach | 6353920 | 2016-08-11 17:21:02 -0400 | [diff] [blame] | 336 | /** validate a combined counter |
| 337 | @param cm - (vlib_combined_counter_main_t *) pointer to the counter |
| 338 | collection |
| 339 | @param index - (u32) index of the counter to validate |
| 340 | */ |
| 341 | |
Dave Barach | 9b8ffd9 | 2016-07-08 08:13:45 -0400 | [diff] [blame] | 342 | void vlib_validate_combined_counter (vlib_combined_counter_main_t * cm, |
| 343 | u32 index); |
Dave Barach | 8341f76 | 2020-06-03 08:05:15 -0400 | [diff] [blame] | 344 | int vlib_validate_combined_counter_will_expand |
| 345 | (vlib_combined_counter_main_t * cm, u32 index); |
| 346 | |
Ole Troan | a568a19 | 2020-04-21 17:54:41 +0200 | [diff] [blame] | 347 | void vlib_free_combined_counter (vlib_combined_counter_main_t * cm); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 348 | |
Dave Barach | 6353920 | 2016-08-11 17:21:02 -0400 | [diff] [blame] | 349 | /** Obtain the number of simple or combined counters allocated. |
| 350 | A macro which reduces to to vec_len(cm->maxi), the answer in either |
| 351 | case. |
| 352 | |
| 353 | @param cm - (vlib_simple_counter_main_t) or |
| 354 | (vlib_combined_counter_main_t) the counter collection to interrogate |
| 355 | @returns vec_len(cm->maxi) |
| 356 | */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 357 | #define vlib_counter_len(cm) vec_len((cm)->maxi) |
| 358 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 359 | #endif /* included_vlib_counter_h */ |
Dave Barach | 9b8ffd9 | 2016-07-08 08:13:45 -0400 | [diff] [blame] | 360 | |
| 361 | /* |
| 362 | * fd.io coding-style-patch-verification: ON |
| 363 | * |
| 364 | * Local Variables: |
| 365 | * eval: (c-set-style "gnu") |
| 366 | * End: |
| 367 | */ |