Line data    Source code

       1             : /*
       2             :  * Copyright (c) 2018 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             : #ifndef __THROTTLE_H__
      17             : #define __THROTTLE_H__
      18             : 
      19             : #include <vlib/vlib.h>
      20             : #include <vppinfra/xxhash.h>
      21             : 
      22             : /**
      23             :  * @brief A throttle
      24             :  *  Used in the data plane to decide if a given hash should be throttled,
      25             :  *  i.e. that the hash has been seen already 'recently'. Recent is the time
      26             :  *  given in the throttle's initialisation.
      27             :  */
      28             : typedef struct throttle_t_
      29             : {
      30             :   f64 time;
      31             :   uword **bitmaps;
      32             :   u64 *seeds;
      33             :   f64 *last_seed_change_time;
      34             :   u32 buckets;
      35             : } throttle_t;
      36             : 
      37             : #define THROTTLE_BITS   (512)
      38             : 
      39             : extern void throttle_init (throttle_t *t, u32 n_threads, u32 buckets,
      40             :                            f64 time);
      41             : 
      42             : always_inline u64
      43         176 : throttle_seed (throttle_t * t, u32 thread_index, f64 time_now)
      44             : {
      45         176 :   if (time_now - t->last_seed_change_time[thread_index] > t->time)
      46             :     {
      47         174 :       (void) random_u64 (&t->seeds[thread_index]);
      48         174 :       clib_bitmap_zero (t->bitmaps[thread_index]);
      49             : 
      50         174 :       t->last_seed_change_time[thread_index] = time_now;
      51             :     }
      52         176 :   return t->seeds[thread_index];
      53             : }
      54             : 
      55             : always_inline int
      56        2397 : throttle_check (throttle_t * t, u32 thread_index, u64 hash, u64 seed)
      57             : {
      58        2397 :   ASSERT (is_pow2 (t->buckets));
      59             : 
      60        2397 :   hash = clib_xxhash (hash ^ seed);
      61             : 
      62             :   /* Select bit number */
      63        2397 :   hash &= t->buckets - 1;
      64             : 
      65        2397 :   return clib_bitmap_set_no_check (t->bitmaps[thread_index], hash, 1);
      66             : }
      67             : 
      68             : #endif
      69             : 
      70             : /*
      71             :  * fd.io coding-style-patch-verification: ON
      72             :  *
      73             :  * Local Variables:
      74             :  * eval: (c-set-style "gnu")
      75             :  * End:
      76             :  */