Line data    Source code

       1             : /*
       2             :  * Copyright (c) 2016 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 __BIER_BIT_STRING_H__
      17             : #define __BIER_BIT_STRING_H__
      18             : 
      19             : #include <vppinfra/byte_order.h>
      20             : #include <vppinfra/format.h>
      21             : 
      22             : #include <vnet/bier/bier_types.h>
      23             : 
      24             : #define BIER_BBS_LEN_TO_BUCKETS(_len) (_len)
      25             : #define BIER_BBS_LEN_TO_BITS(_len) (_len * 8)
      26             : #define BIER_BBS_LEN_TO_INTS(_len) ((_len) / sizeof(int))
      27             : #define BIER_BIT_MASK_BITS_PER_INT (sizeof(int) * 8)
      28             : 
      29             : /*
      30             :  * bier_find_first_bit_set
      31             :  *
      32             :  * find the position of the first bit set in a long
      33             :  */
      34             : static inline int
      35       67916 : bier_find_first_bit_string_set (int mask)
      36             : {
      37       67916 :     return (__builtin_ffs(clib_net_to_host_u32(mask)));
      38             : }
      39             : 
      40             : extern void bier_bit_string_set_bit(bier_bit_string_t *mask,
      41             :                                     bier_bp_t bp);
      42             : 
      43             : 
      44             : extern void bier_bit_string_clear_bit(bier_bit_string_t *mask,
      45             :                                       bier_bp_t bp);
      46             : 
      47             : 
      48             : extern u8 *format_bier_bit_string(u8 * s, va_list * args);
      49             : 
      50             : #define BIER_BBS_NUM_INT_BUCKETS(_bbs) \
      51             :     (BIER_BBS_LEN_TO_BUCKETS(_bbs->bbs_len) / sizeof(int))
      52             : 
      53             : always_inline int
      54             : bier_bit_string_is_zero (const bier_bit_string_t *src)
      55             : {
      56             :     u16 index;
      57             : 
      58             :     for (index = 0;
      59             :          index < BIER_BBS_NUM_INT_BUCKETS(src);
      60             :          index++) {
      61             :         if (((int*)src->bbs_buckets)[index] != 0) {
      62             :             return (0);
      63             :         }
      64             :     }
      65             :     return (1);
      66             : }
      67             : 
      68             : always_inline void
      69        1042 : bier_bit_string_clear_string (const bier_bit_string_t *src,
      70             :                               bier_bit_string_t *dest)
      71             : {
      72             :     u16 index;
      73             : 
      74        1042 :     ASSERT(src->bbs_len == dest->bbs_len);
      75             : 
      76        1042 :     for (index = 0;
      77        3180 :          index < BIER_BBS_NUM_INT_BUCKETS(src);
      78        2138 :          index++) {
      79        2138 :         ((int*)dest->bbs_buckets)[index] &= ~(((int*)src->bbs_buckets)[index]);
      80             :     }
      81        1042 : }
      82             : 
      83             : always_inline void
      84        1042 : bier_bit_string_logical_and_string (const bier_bit_string_t *src,
      85             :                                     bier_bit_string_t *dest)
      86             : {
      87             :     u16 index;
      88             : 
      89        1042 :     ASSERT(src->bbs_len == dest->bbs_len);
      90             : 
      91        1042 :     for (index = 0;
      92        3180 :          index < BIER_BBS_NUM_INT_BUCKETS(src);
      93        2138 :          index++) {
      94        2138 :         ((int*)dest->bbs_buckets)[index] &= ((int*)src->bbs_buckets)[index];
      95             :     }
      96        1042 : }
      97             : 
      98             : always_inline void
      99        1345 : bier_bit_string_init (bier_bit_string_t *bbs,
     100             :                       bier_hdr_len_id_t len,
     101             :                       bier_bit_mask_bucket_t *buckets)
     102             : {
     103        1345 :     bbs->bbs_len = bier_hdr_len_id_to_num_bytes(len);
     104        1345 :     bbs->bbs_buckets = buckets;
     105        1345 : }
     106             : 
     107             : #endif