vpp之clib.h分析

vpp代码中有一个clib.h，其中封装了很一些很经典的位运算：

 //计算以2为底的对数，log2(x)
 //也就是计算2的N次方为x。x为uint32类型
 #if defined (count_leading_zeros)
 always_inline uword
 min_log2 (uword x)
 {
     uword n;
     n = count_leading_zeros (x);
     return BITS (uword) - n - ;
 }
 #else
 always_inline uword
 min_log2 (uword x)
 {
     uword a = x, b = BITS (uword) / , c = , r = ;

     /* Reduce x to 4 bit result. */
 #define _                   \
     {                       \
       c = a >> b;                   \
       if (c) a = c;                 \
       if (c) r += b;                \
       b /= ;                   \
     }

     if (BITS (uword) > )
         _;
     _;
     _;
     _;
 #undef _

     /* Do table lookup on 4 bit partial. */
     if (BITS (uword) > )
     {
         const u64 table = 0x3333333322221104LL;
         uword t = (table >> ( * a)) & 0xf;
         r = t <  ? r + t : ~;
     }
     else
     {
         const u32 table = 0x22221104;
         uword t = (a & ) ?  : ((table >> ( * a)) & 0xf);
         r = t <  ? r + t : ~;
     }

     return r;
 }
 #endif

 //计算以2为底的对数（有余数的话+1），log2(x)
 //也就是计算2的N次方为x。2的N次方大于x
 always_inline uword
 max_log2 (uword x)
 {
     uword l = min_log2 (x);
     if (x > ((uword)  << l))
         l++;
     return l;
 }

 //计算以2为底的对数，log2(x)
 //也就是计算2的N次方为x。x为u64类型
 always_inline u64
 min_log2_u64 (u64 x)
 {
     if (BITS (uword) == )
         return min_log2 (x);
     else
     {
         uword l, y;
         y = x;
         l = ;
         if (y == )
         {
             l += ;
             x >>= ;
         }
         l += min_log2 (x);
         return l;
     }
 }

 //计算基数2的x次幂的值对应的掩码
 //比如2的4次幂为16，对应的掩码为15
 always_inline uword
 pow2_mask (uword x)
 {
     return ((uword)  << x) - (uword) ;
 }

 //计算数字x对应的，以基数2的n次幂的值。x小于等于n
 //比如x=15，则得出的数字为16.2的3次幂小于x，2的4次幂大于x。
 always_inline uword
 max_pow2 (uword x)
 {
     word y = (word)  << min_log2 (x);
     if (x > y)
         y *= ;
     return y;
 }

 //计算x是否可等于基数2的n次幂
 //比如x=16，返回1.x=15，返回0
 always_inline uword
 is_pow2 (uword x)
 {
     return  == (x & (x - ));
 }

 //计算x以pow2对齐的长度。pow2应该为2的n次方。
 //如x=15，pow2=4，则返回16。
 always_inline uword
 round_pow2 (uword x, uword pow2)
 {
     return (x + pow2 - ) & ~(pow2 - );
 }

 //计算x以pow2对齐的长度。pow2应该为2的n次方。
 //如x=15，pow2=4，则返回16。
 always_inline u64
 round_pow2_u64 (u64 x, u64 pow2)
 {
     return (x + pow2 - ) & ~(pow2 - );
 }

 //保留二进制下最后出现的1的位置，其余位置置0（即一个数中最大的2的n次幂的因数
 //当一个偶数与它的负值向与时，结果是能被这个偶数整除的最大的2的n次幂
 //当一个奇数与它的负值向与时结果一定是1
 always_inline uword
 first_set (uword x)
 {
     return x & -x;
 }

 //先将x用first_set计算结果，
 //然后以2为底做对数运算
 always_inline uword
 log2_first_set (uword x)
 {
     uword result;
 #ifdef count_trailing_zeros
     result = count_trailing_zeros (x);
 #else
     result = min_log2 (first_set (x));
 #endif
     return result;
 }

 //将浮点数强转为整型（小数部分舍去）
 always_inline f64
 flt_round_down (f64 x)
 {
     return (int) x;
 }

 //将浮点数强转为整型（小数部分四舍五入）
 always_inline word
 flt_round_nearest (f64 x)
 {
     return (word) (x + .);
 }

 //若x大于f的一半，则返回f，否则返回0
 always_inline f64
 flt_round_to_multiple (f64 x, f64 f)
 {
     return f * flt_round_nearest (x / f);
 }

 //计算x右移start位后，再截取count位有效数字是多少
 always_inline uword
 extract_bits (uword x, int start, int count)
 {
 #ifdef __BMI__
     return _bextr_u64 (x, start, count);
 #endif
     return (x >> start) & pow2_mask (count);
 }

 //取x和y两个数中大的数
 #define clib_max(x,y)               \
 ({                      \
   __typeof__ (x) _x = (x);          \
   __typeof__ (y) _y = (y);          \
   _x > _y ? _x : _y;                \
 })

 //取x和y两个数中较小的数
 #define clib_min(x,y)               \
 ({                      \
   __typeof__ (x) _x = (x);          \
   __typeof__ (y) _y = (y);          \
   _x < _y ? _x : _y;                \
 })

 //取x和y两个数中较大的数
 #define clib_max(x,y)               \
 ({                      \
   __typeof__ (x) _x = (x);          \
   __typeof__ (y) _y = (y);          \
   _x > _y ? _x : _y;                \
 })

 //取x的绝对值
 //定义类型与x相同的临时变量_x，并将x的值赋予_x
 //取绝对值
 #define clib_abs(x)             \
 ({                      \
   __typeof__ (x) _x = (x);         \
   _x <  ? -_x : _x;                \
 })