src/vlib/counter.h

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