//计算以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;                \

 })