Cách nhanh nhất / hiệu quả nhất để tìm bit đặt cao nhất (msb) trong một số nguyên trong C là gì?

Nếu tôi có một số nguyên n và tôi muốn biết vị trí của bit quan trọng nhất (nghĩa là, nếu bit quan trọng nhất ở bên phải, tôi muốn biết vị trí của bit xa nhất bên trái là 1), phương pháp tìm hiểu nhanh nhất / hiệu quả nhất là gì?

Tôi biết rằng POSIX hỗ trợ một ffs()phương thức trong string.h để tìm bit đặt đầu tiên, nhưng dường như không có fls()phương thức tương ứng .

Có một số cách thực sự rõ ràng để làm điều này mà tôi đang thiếu không?

Còn trong trường hợp bạn không thể sử dụng các chức năng POSIX để di động thì sao?

Chỉnh sửa: Còn về một giải pháp hoạt động trên cả kiến ​​trúc 32 và 64 bit (nhiều danh sách mã có vẻ như chúng chỉ hoạt động trên các int 32 bit).

GCC có :

 - Hàm tích hợp: int __builtin_clz (unsigned int x)
     Trả về số bit 0 đứng đầu trong X, bắt đầu từ nhiều nhất
     vị trí bit đáng kể. Nếu X là 0, kết quả là không xác định.

 - Hàm tích hợp: int __builtin_clzl (unsigned long)
     Tương tự như `__builtin_clz ', ngoại trừ kiểu đối số là` không dấu
     Dài'.

 - Hàm tích hợp: int __builtin_clzll (dài dài không dấu)
     Tương tự như `__builtin_clz ', ngoại trừ kiểu đối số là` không dấu
     dài dài'.

Tôi hy vọng chúng sẽ được dịch thành một thứ gì đó hiệu quả hợp lý cho nền tảng hiện tại của bạn, cho dù đó là một trong những thuật toán xoắn bit lạ mắt hay một chỉ dẫn duy nhất.

Một mẹo hữu ích nếu đầu vào của bạn có thể bằng 0 là __builtin_clz(x | 1): đặt bit thấp một cách vô điều kiện mà không sửa đổi bất kỳ người nào khác tạo đầu ra 31cho x=0mà không thay đổi đầu ra cho bất kỳ đầu vào nào khác.

Để tránh cần phải làm điều đó, tùy chọn khác của bạn là bản chất nền tảng cụ thể như ARM GCC __clz(không cần tiêu đề) hoặc x86 _lzcnt_u32trên các CPU hỗ trợ lzcntlệnh. (Hãy lưu ý rằng lzcntgiải mã như bsrtrên các CPU cũ hơn thay vì lỗi, cung cấp 31-lzcnt cho các đầu vào khác không.)

Thật không may, không có cách nào để tận dụng lợi thế của các lệnh CLZ khác nhau trên các nền tảng không phải x86 xác định kết quả cho đầu vào = 0 là 32 hoặc 64 (theo chiều rộng toán hạng). x86 cũng lzcntlàm điều đó, trong khi bsrtạo ra một chỉ mục bit mà trình biên dịch phải lật trừ khi bạn sử dụng 31-__builtin_clz(x).

("Kết quả không xác định" không phải là Hành vi không xác định C, chỉ là một giá trị không được xác định. Nó thực sự là bất cứ thứ gì có trong thanh ghi đích khi lệnh chạy. AMD ghi lại điều này, Intel thì không, nhưng CPU của Intel thực hiện hành vi đó . Nhưng nó không phải là bất cứ thứ gì trước đây trong biến C mà bạn đang gán, đó thường không phải là cách mọi thứ hoạt động khi gcc biến C thành asm. Xem thêm Tại sao việc phá vỡ "sự phụ thuộc đầu ra" của LZCNT lại quan trọng? )

Giả sử bạn đang sử dụng x86 và chơi trò chơi để tìm kiếm một chút trình biên dịch nội tuyến, Intel sẽ cung cấp một BSRhướng dẫn ("đảo ngược quét bit"). Nó nhanh trên một số x86 (được mã vi mô trên những người khác). Từ sách hướng dẫn:

Tìm kiếm toán hạng nguồn cho bit đặt quan trọng nhất (1 bit). Nếu một bit quan trọng nhất được tìm thấy, chỉ số bit của nó được lưu trữ trong toán hạng đích. Toán hạng nguồn có thể là một thanh ghi hoặc một vị trí bộ nhớ; toán hạng đích là một thanh ghi. Chỉ số bit là một độ lệch không dấu từ bit 0 của toán hạng nguồn. Nếu toán hạng nguồn nội dung là 0, thì nội dung của toán hạng đích là không xác định.

(Nếu bạn đang sử dụng PowerPC, có một lệnh tương tự cntlz("đếm số không ở đầu").)

Mã mẫu cho gcc:

#include <iostream>

int main (int,char**)
{
  int n=1;
  for (;;++n) {
    int msb;
    asm("bsrl %1,%0" : "=r"(msb) : "r"(n));
    std::cout << n << " : " << msb << std::endl;
  }
  return 0;
}

Xem thêm hướng dẫn trình hợp ngữ nội tuyến này , cho thấy (phần 9.4) nó nhanh hơn đáng kể so với mã lặp.

Vì 2 ^ N là số nguyên chỉ có tập bit thứ N (1 << N), nên việc tìm vị trí (N) của bit tập cao nhất là số nguyên log cơ số 2 của số nguyên đó.

http://graphics.stanford.edu/~seander/bithacks.html#IntegerLogObvious

unsigned int v;
unsigned r = 0;

while (v >>= 1) {
    r++;
}

Thuật toán "hiển nhiên" này có thể không minh bạch với tất cả mọi người, nhưng khi bạn nhận ra rằng mã dịch chuyển sang phải từng bit liên tục cho đến khi bit ngoài cùng bên trái bị dịch chuyển (lưu ý rằng C coi mọi giá trị khác 0 là đúng) và trả về số thay đổi, nó có ý nghĩa hoàn hảo. Nó cũng có nghĩa là nó hoạt động ngay cả khi nhiều hơn một bit được thiết lập - kết quả luôn dành cho bit quan trọng nhất.

Nếu bạn cuộn xuống trên trang đó, sẽ có những biến thể nhanh hơn, phức tạp hơn. Tuy nhiên, nếu bạn biết rằng bạn đang xử lý các số có nhiều số 0 ở đầu, thì cách tiếp cận đơn giản có thể cung cấp tốc độ chấp nhận được, vì dịch chuyển bit khá nhanh trong C và thuật toán đơn giản không yêu cầu lập chỉ mục một mảng.

LƯU Ý: Khi sử dụng các giá trị 64-bit, hãy cực kỳ thận trọng khi sử dụng các thuật toán cực kỳ thông minh; nhiều trong số chúng chỉ hoạt động chính xác cho các giá trị 32-bit.

Điều này sẽ nhanh như chớp:

int msb(unsigned int v) {
  static const int pos[32] = {0, 1, 28, 2, 29, 14, 24, 3,
    30, 22, 20, 15, 25, 17, 4, 8, 31, 27, 13, 23, 21, 19,
    16, 7, 26, 12, 18, 6, 11, 5, 10, 9};
  v |= v >> 1;
  v |= v >> 2;
  v |= v >> 4;
  v |= v >> 8;
  v |= v >> 16;
  v = (v >> 1) + 1;
  return pos[(v * 0x077CB531UL) >> 27];
}

Điều này giống như tìm một loại nhật ký số nguyên. Có những thủ thuật lộn xộn, nhưng tôi đã tạo ra công cụ của riêng mình cho việc này. Mục tiêu tất nhiên là tốc độ.

Nhận thức của tôi là CPU đã có một bộ dò bit tự động, được sử dụng để chuyển đổi số nguyên sang số thực! Vì vậy, hãy sử dụng cái đó.

double ff=(double)(v|1);
return ((*(1+(uint32_t *)&ff))>>20)-1023;  // assumes x86 endianness

Phiên bản này chuyển giá trị thành nhân đôi, sau đó đọc số mũ, điều này cho bạn biết vị trí của bit. Phép chuyển và phép trừ ưa thích là trích xuất các phần thích hợp từ giá trị IEEE.

Sử dụng phao nổi sẽ nhanh hơn một chút, nhưng phao chỉ có thể cung cấp cho bạn 24 vị trí bit đầu tiên vì độ chính xác của nó nhỏ hơn.

Để thực hiện việc này một cách an toàn, không có hành vi không xác định trong C ++ hoặc C, hãy sử dụng memcpythay vì ép kiểu con trỏ cho kiểu-punning. Trình biên dịch biết làm thế nào để nội dòng nó một cách hiệu quả.

// static_assert(sizeof(double) == 2 * sizeof(uint32_t), "double isn't 8-byte IEEE binary64");
// and also static_assert something about FLT_ENDIAN?

double ff=(double)(v|1);

uint32_t tmp;
memcpy(&tmp, ((const char*)&ff)+sizeof(uint32_t), sizeof(uint32_t));
return (tmp>>20)-1023;

Hoặc trong C99 trở lên, sử dụng a union {double d; uint32_t u[2];};. Nhưng lưu ý rằng trong C ++, punning type union chỉ được hỗ trợ trên một số trình biên dịch dưới dạng phần mở rộng, không phải trong ISO C ++.

Điều này thường sẽ chậm hơn so với nội tại của nền tảng cụ thể đối với hướng dẫn đếm số không ở đầu, nhưng ISO C di động không có chức năng này. Một số CPU cũng thiếu lệnh đếm số 0 đứng đầu, nhưng một số CPU có thể chuyển đổi số nguyên thành một cách hiệu quả double. Tuy nhiên, việc gõ-punning một mẫu bit FP trở về số nguyên có thể chậm (ví dụ: trên PowerPC, nó yêu cầu lưu trữ / tải lại và thường gây ra tình trạng ngừng tải tại cửa hàng).

Thuật toán này có thể hữu ích cho việc triển khai SIMD, vì ít CPU có SIMD hơn lzcnt. x86 chỉ có một lệnh như vậy với AVX512CD

Kaz Kylheku đây

Tôi đã đánh giá hai phương pháp tiếp cận cho các số hơn 63 bit này (loại dài dài trên gcc x86_64), tránh xa bit dấu.

(Tôi tình cờ cần "tìm bit cao nhất" này cho một cái gì đó, bạn thấy đấy.)

Tôi đã triển khai tìm kiếm nhị phân theo hướng dữ liệu (dựa trên một trong các câu trả lời ở trên). Tôi cũng đã triển khai một cây quyết định hoàn toàn không được cuộn bằng tay, nó chỉ là mã với các toán hạng ngay lập tức. Không có vòng lặp, không có bảng.

Cây quyết định (cao nhất_bit_unrolled) được chuẩn hóa để nhanh hơn 69%, ngoại trừ trường hợp n = 0 mà tìm kiếm nhị phân có một thử nghiệm rõ ràng.

Kiểm tra đặc biệt của tìm kiếm nhị phân cho trường hợp 0 ​​chỉ nhanh hơn 48% so với cây quyết định, không có kiểm tra đặc biệt.

Trình biên dịch, máy: (GCC 4.5.2, -O3, x86-64, 2867 Mhz Intel Core i5).

int highest_bit_unrolled(long long n)
{
  if (n & 0x7FFFFFFF00000000) {
    if (n & 0x7FFF000000000000) {
      if (n & 0x7F00000000000000) {
        if (n & 0x7000000000000000) {
          if (n & 0x4000000000000000)
            return 63;
          else
            return (n & 0x2000000000000000) ? 62 : 61;
        } else {
          if (n & 0x0C00000000000000)
            return (n & 0x0800000000000000) ? 60 : 59;
          else
            return (n & 0x0200000000000000) ? 58 : 57;
        }
      } else {
        if (n & 0x00F0000000000000) {
          if (n & 0x00C0000000000000)
            return (n & 0x0080000000000000) ? 56 : 55;
          else
            return (n & 0x0020000000000000) ? 54 : 53;
        } else {
          if (n & 0x000C000000000000)
            return (n & 0x0008000000000000) ? 52 : 51;
          else
            return (n & 0x0002000000000000) ? 50 : 49;
        }
      }
    } else {
      if (n & 0x0000FF0000000000) {
        if (n & 0x0000F00000000000) {
          if (n & 0x0000C00000000000)
            return (n & 0x0000800000000000) ? 48 : 47;
          else
            return (n & 0x0000200000000000) ? 46 : 45;
        } else {
          if (n & 0x00000C0000000000)
            return (n & 0x0000080000000000) ? 44 : 43;
          else
            return (n & 0x0000020000000000) ? 42 : 41;
        }
      } else {
        if (n & 0x000000F000000000) {
          if (n & 0x000000C000000000)
            return (n & 0x0000008000000000) ? 40 : 39;
          else
            return (n & 0x0000002000000000) ? 38 : 37;
        } else {
          if (n & 0x0000000C00000000)
            return (n & 0x0000000800000000) ? 36 : 35;
          else
            return (n & 0x0000000200000000) ? 34 : 33;
        }
      }
    }
  } else {
    if (n & 0x00000000FFFF0000) {
      if (n & 0x00000000FF000000) {
        if (n & 0x00000000F0000000) {
          if (n & 0x00000000C0000000)
            return (n & 0x0000000080000000) ? 32 : 31;
          else
            return (n & 0x0000000020000000) ? 30 : 29;
        } else {
          if (n & 0x000000000C000000)
            return (n & 0x0000000008000000) ? 28 : 27;
          else
            return (n & 0x0000000002000000) ? 26 : 25;
        }
      } else {
        if (n & 0x0000000000F00000) {
          if (n & 0x0000000000C00000)
            return (n & 0x0000000000800000) ? 24 : 23;
          else
            return (n & 0x0000000000200000) ? 22 : 21;
        } else {
          if (n & 0x00000000000C0000)
            return (n & 0x0000000000080000) ? 20 : 19;
          else
            return (n & 0x0000000000020000) ? 18 : 17;
        }
      }
    } else {
      if (n & 0x000000000000FF00) {
        if (n & 0x000000000000F000) {
          if (n & 0x000000000000C000)
            return (n & 0x0000000000008000) ? 16 : 15;
          else
            return (n & 0x0000000000002000) ? 14 : 13;
        } else {
          if (n & 0x0000000000000C00)
            return (n & 0x0000000000000800) ? 12 : 11;
          else
            return (n & 0x0000000000000200) ? 10 : 9;
        }
      } else {
        if (n & 0x00000000000000F0) {
          if (n & 0x00000000000000C0)
            return (n & 0x0000000000000080) ? 8 : 7;
          else
            return (n & 0x0000000000000020) ? 6 : 5;
        } else {
          if (n & 0x000000000000000C)
            return (n & 0x0000000000000008) ? 4 : 3;
          else
            return (n & 0x0000000000000002) ? 2 : (n ? 1 : 0);
        }
      }
    }
  }
}

int highest_bit(long long n)
{
  const long long mask[] = {
    0x000000007FFFFFFF,
    0x000000000000FFFF,
    0x00000000000000FF,
    0x000000000000000F,
    0x0000000000000003,
    0x0000000000000001
  };
  int hi = 64;
  int lo = 0;
  int i = 0;

  if (n == 0)
    return 0;

  for (i = 0; i < sizeof mask / sizeof mask[0]; i++) {
    int mi = lo + (hi - lo) / 2;

    if ((n >> mi) != 0)
      lo = mi;
    else if ((n & (mask[i] << lo)) != 0)
      hi = mi;
  }

  return lo + 1;
}

Chương trình kiểm tra nhanh và bẩn:

#include <stdio.h>
#include <time.h>
#include <stdlib.h>

int highest_bit_unrolled(long long n);
int highest_bit(long long n);

main(int argc, char **argv)
{
  long long n = strtoull(argv[1], NULL, 0);
  int b1, b2;
  long i;
  clock_t start = clock(), mid, end;

  for (i = 0; i < 1000000000; i++)
    b1 = highest_bit_unrolled(n);

  mid = clock();

  for (i = 0; i < 1000000000; i++)
    b2 = highest_bit(n);

  end = clock();

  printf("highest bit of 0x%llx/%lld = %d, %d\n", n, n, b1, b2);

  printf("time1 = %d\n", (int) (mid - start));
  printf("time2 = %d\n", (int) (end - mid));
  return 0;
}

Chỉ sử dụng -O2, sự khác biệt trở nên lớn hơn. Cây quyết định nhanh hơn gần bốn lần.

Tôi cũng đã so sánh với mã dịch chuyển bit ngây thơ:

int highest_bit_shift(long long n)
{
  int i = 0;
  for (; n; n >>= 1, i++)
    ; /* empty */
  return i;
}

Điều này chỉ nhanh đối với số lượng nhỏ, như người ta mong đợi. Khi xác định rằng bit cao nhất là 1 cho n == 1, nó đã định chuẩn nhanh hơn 80%. Tuy nhiên, một nửa số được chọn ngẫu nhiên trong không gian 63 bit có bit thứ 63!

Trên đầu vào 0x3FFFFFFFFFFFFFFF, phiên bản cây quyết định nhanh hơn một chút so với phiên bản 1 và nhanh hơn 1120% (12,2 lần) so với bộ dịch chuyển bit.

Tôi cũng sẽ đánh giá chuẩn cây quyết định so với nội trang GCC và cũng thử kết hợp các đầu vào thay vì lặp lại với cùng một số. Có thể có một số dự đoán nhánh dính đang xảy ra và có lẽ một số tình huống bộ nhớ đệm không thực tế khiến nó nhanh hơn một cách giả tạo khi lặp lại.

Thế còn

int highest_bit(unsigned int a) {
    int count;
    std::frexp(a, &count);
    return count - 1;
}

?

unsigned int
msb32(register unsigned int x)
{
        x |= (x >> 1);
        x |= (x >> 2);
        x |= (x >> 4);
        x |= (x >> 8);
        x |= (x >> 16);
        return(x & ~(x >> 1));
}

1 thanh ghi, 13 hướng dẫn. Tin hay không thì tùy, điều này thường nhanh hơn lệnh BSR được đề cập ở trên, hoạt động theo thời gian tuyến tính. Đây là thời gian logarit.

Từ http://aggregate.org/MAGIC/#Most%20Significant%201%20Bit

Dưới đây là một số điểm chuẩn (đơn giản) của các thuật toán hiện được đưa ra trên trang này ...

Các thuật toán chưa được kiểm tra trên tất cả các đầu vào của int unsigned; vì vậy hãy kiểm tra điều đó trước, trước khi sử dụng thứ gì đó một cách mù quáng;)

Trên máy của tôi, clz (__builtin_clz) và asm hoạt động tốt nhất. asm dường như thậm chí còn nhanh hơn sau đó clz ... nhưng nó có thể là do điểm chuẩn đơn giản ...

//////// go.c ///////////////////////////////
// compile with:  gcc go.c -o go -lm
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

/***************** math ********************/

#define POS_OF_HIGHESTBITmath(a) /* 0th position is the Least-Signif-Bit */    \
  ((unsigned) log2(a))         /* thus: do not use if a <= 0 */  

#define NUM_OF_HIGHESTBITmath(a) ((a)               \
                  ? (1U << POS_OF_HIGHESTBITmath(a))    \
                  : 0)



/***************** clz ********************/

unsigned NUM_BITS_U = ((sizeof(unsigned) << 3) - 1);
#define POS_OF_HIGHESTBITclz(a) (NUM_BITS_U - __builtin_clz(a)) /* only works for a != 0 */

#define NUM_OF_HIGHESTBITclz(a) ((a)                    \
                 ? (1U << POS_OF_HIGHESTBITclz(a))  \
                 : 0)


/***************** i2f ********************/

double FF;
#define POS_OF_HIGHESTBITi2f(a) (FF = (double)(ui|1), ((*(1+(unsigned*)&FF))>>20)-1023)


#define NUM_OF_HIGHESTBITi2f(a) ((a)                    \
                 ? (1U << POS_OF_HIGHESTBITi2f(a))  \
                 : 0)




/***************** asm ********************/

unsigned OUT;
#define POS_OF_HIGHESTBITasm(a) (({asm("bsrl %1,%0" : "=r"(OUT) : "r"(a));}), OUT)

#define NUM_OF_HIGHESTBITasm(a) ((a)                    \
                 ? (1U << POS_OF_HIGHESTBITasm(a))  \
                 : 0)




/***************** bitshift1 ********************/

#define NUM_OF_HIGHESTBITbitshift1(a) (({   \
  OUT = a;                  \
  OUT |= (OUT >> 1);                \
  OUT |= (OUT >> 2);                \
  OUT |= (OUT >> 4);                \
  OUT |= (OUT >> 8);                \
  OUT |= (OUT >> 16);               \
      }), (OUT & ~(OUT >> 1)))          \



/***************** bitshift2 ********************/
int POS[32] = {0, 1, 28, 2, 29, 14, 24, 3,
             30, 22, 20, 15, 25, 17, 4, 8, 31, 27, 13, 23, 21, 19,
             16, 7, 26, 12, 18, 6, 11, 5, 10, 9};

#define POS_OF_HIGHESTBITbitshift2(a) (({   \
  OUT = a;                  \
  OUT |= OUT >> 1;              \
  OUT |= OUT >> 2;              \
  OUT |= OUT >> 4;              \
  OUT |= OUT >> 8;              \
  OUT |= OUT >> 16;             \
  OUT = (OUT >> 1) + 1;             \
      }), POS[(OUT * 0x077CB531UL) >> 27])

#define NUM_OF_HIGHESTBITbitshift2(a) ((a)              \
                       ? (1U << POS_OF_HIGHESTBITbitshift2(a)) \
                       : 0)



#define LOOPS 100000000U

int main()
{
  time_t start, end;
  unsigned ui;
  unsigned n;

  /********* Checking the first few unsigned values (you'll need to check all if you want to use an algorithm here) **************/
  printf("math\n");
  for (ui = 0U; ui < 18; ++ui)
    printf("%i\t%i\n", ui, NUM_OF_HIGHESTBITmath(ui));

  printf("\n\n");

  printf("clz\n");
  for (ui = 0U; ui < 18U; ++ui)
    printf("%i\t%i\n", ui, NUM_OF_HIGHESTBITclz(ui));

  printf("\n\n");

  printf("i2f\n");
  for (ui = 0U; ui < 18U; ++ui)
    printf("%i\t%i\n", ui, NUM_OF_HIGHESTBITi2f(ui));

  printf("\n\n");

  printf("asm\n");
  for (ui = 0U; ui < 18U; ++ui) {
    printf("%i\t%i\n", ui, NUM_OF_HIGHESTBITasm(ui));
  }

  printf("\n\n");

  printf("bitshift1\n");
  for (ui = 0U; ui < 18U; ++ui) {
    printf("%i\t%i\n", ui, NUM_OF_HIGHESTBITbitshift1(ui));
  }

  printf("\n\n");

  printf("bitshift2\n");
  for (ui = 0U; ui < 18U; ++ui) {
    printf("%i\t%i\n", ui, NUM_OF_HIGHESTBITbitshift2(ui));
  }

  printf("\n\nPlease wait...\n\n");


  /************************* Simple clock() benchmark ******************/
  start = clock();
  for (ui = 0; ui < LOOPS; ++ui)
    n = NUM_OF_HIGHESTBITmath(ui);
  end = clock();
  printf("math:\t%e\n", (double)(end-start)/CLOCKS_PER_SEC);

  start = clock();
  for (ui = 0; ui < LOOPS; ++ui)
    n = NUM_OF_HIGHESTBITclz(ui);
  end = clock();
  printf("clz:\t%e\n", (double)(end-start)/CLOCKS_PER_SEC);

  start = clock();
  for (ui = 0; ui < LOOPS; ++ui)
    n = NUM_OF_HIGHESTBITi2f(ui);
  end = clock();
  printf("i2f:\t%e\n", (double)(end-start)/CLOCKS_PER_SEC);

  start = clock();
  for (ui = 0; ui < LOOPS; ++ui)
    n = NUM_OF_HIGHESTBITasm(ui);
  end = clock();
  printf("asm:\t%e\n", (double)(end-start)/CLOCKS_PER_SEC);

  start = clock();
  for (ui = 0; ui < LOOPS; ++ui)
    n = NUM_OF_HIGHESTBITbitshift1(ui);
  end = clock();
  printf("bitshift1:\t%e\n", (double)(end-start)/CLOCKS_PER_SEC);

  start = clock();
  for (ui = 0; ui < LOOPS; ++ui)
    n = NUM_OF_HIGHESTBITbitshift2(ui);
  end = clock();
  printf("bitshift2\t%e\n", (double)(end-start)/CLOCKS_PER_SEC);

  printf("\nThe lower, the better. Take note that a negative exponent is good! ;)\n");

  return EXIT_SUCCESS;
}

Mặc dù tôi có thể sẽ chỉ sử dụng phương pháp này nếu tôi thực sự yêu cầu hiệu suất tốt nhất có thể (ví dụ: để viết một số loại trò chơi hội đồng AI liên quan đến bitboard), giải pháp hiệu quả nhất là sử dụng ASM nội tuyến. Xem phần Tối ưu của bài đăng trên blog này để biết mã có giải thích.

[...], lệnh hợp bsrlngữ tính toán vị trí của bit quan trọng nhất. Do đó, chúng ta có thể sử dụng asmcâu lệnh này :

asm ("bsrl %1, %0" 
     : "=r" (position) 
     : "r" (number));

Tôi cần có một thói quen để làm điều này và trước khi tìm kiếm trên web (và tìm trang này), tôi đã đưa ra giải pháp của riêng mình dựa trên tìm kiếm nhị phân. Mặc dù tôi chắc chắn rằng ai đó đã làm điều này trước đây! Nó chạy trong thời gian liên tục và có thể nhanh hơn so với giải pháp "hiển nhiên" đã đăng, mặc dù tôi không đưa ra bất kỳ tuyên bố lớn nào, chỉ đăng nó vì sự quan tâm.

int highest_bit(unsigned int a) {
  static const unsigned int maskv[] = { 0xffff, 0xff, 0xf, 0x3, 0x1 };
  const unsigned int *mask = maskv;
  int l, h;

  if (a == 0) return -1;

  l = 0;
  h = 32;

  do {
    int m = l + (h - l) / 2;

    if ((a >> m) != 0) l = m;
    else if ((a & (*mask << l)) != 0) h = m;

    mask++;
  } while (l < h - 1);

  return l;
}

đó là một số loại tìm kiếm nhị phân, nó hoạt động với tất cả các loại số nguyên (không dấu!)

#include <climits>
#define UINT (unsigned int)
#define UINT_BIT (CHAR_BIT*sizeof(UINT))

int msb(UINT x)
{
    if(0 == x)
        return -1;

    int c = 0;

    for(UINT i=UINT_BIT>>1; 0<i; i>>=1)
    if(static_cast<UINT>(x >> i))
    {
        x >>= i;
        c |= i;
    }

    return c;
}

để hoàn thành:

#include <climits>
#define UINT unsigned int
#define UINT_BIT (CHAR_BIT*sizeof(UINT))

int lsb(UINT x)
{
    if(0 == x)
        return -1;

    int c = UINT_BIT-1;

    for(UINT i=UINT_BIT>>1; 0<i; i>>=1)
    if(static_cast<UINT>(x << i))
    {
        x <<= i;
        c ^= i;
    }

    return c;
}

Một số câu trả lời quá phức tạp ở đây. Kỹ thuật Debruin chỉ nên được sử dụng khi đầu vào đã là lũy thừa của hai, nếu không sẽ có một cách tốt hơn. Đối với sức mạnh của 2 đầu vào, Debruin là nhanh nhất tuyệt đối, thậm chí nhanh hơn _BitScanReversebất kỳ bộ xử lý nào mà tôi đã thử nghiệm. Tuy nhiên, trong trường hợp chung,_BitScanReverse (hoặc bất cứ thứ gì nội tại được gọi trong trình biên dịch của bạn) là nhanh nhất (trên một số CPU nhất định, nó có thể được mã hóa vi mô).

Nếu chức năng nội tại không phải là một tùy chọn, thì đây là một giải pháp phần mềm tối ưu để xử lý các đầu vào chung.

u8  inline log2 (u32 val)  {
    u8  k = 0;
    if (val > 0x0000FFFFu) { val >>= 16; k  = 16; }
    if (val > 0x000000FFu) { val >>= 8;  k |= 8;  }
    if (val > 0x0000000Fu) { val >>= 4;  k |= 4;  }
    if (val > 0x00000003u) { val >>= 2;  k |= 2;  }
    k |= (val & 2) >> 1;
    return k;
}

Lưu ý rằng phiên bản này không yêu cầu tra cứu Debruin ở cuối, không giống như hầu hết các câu trả lời khác. Nó tính toán vị trí tại chỗ.

Mặc dù vậy, bảng có thể được ưu tiên hơn, nếu bạn gọi nó liên tục đủ lần, nguy cơ bỏ lỡ bộ nhớ cache sẽ bị lu mờ bởi tốc độ tăng tốc của bảng.

u8 kTableLog2[256] = {
0,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7
};

u8 log2_table(u32 val)  {
    u8  k = 0;
    if (val > 0x0000FFFFuL) { val >>= 16; k  = 16; }
    if (val > 0x000000FFuL) { val >>=  8; k |=  8; }
    k |= kTableLog2[val]; // precompute the Log2 of the low byte

    return k;
}

Điều này sẽ tạo ra thông lượng cao nhất trong số các câu trả lời phần mềm được đưa ra ở đây, nhưng nếu bạn chỉ thỉnh thoảng gọi nó, hãy thích một giải pháp không cần bảng như đoạn mã đầu tiên của tôi.

Như các câu trả lời ở trên đã chỉ ra, có một số cách để xác định bit quan trọng nhất. Tuy nhiên, như cũng đã chỉ ra, các phương thức có thể là duy nhất cho thanh ghi 32bit hoặc 64bit. Các trang bithacks stanford.edu cung cấp giải pháp mà làm việc cho cả 32bit và 64bit máy tính. Với một chút công việc, chúng có thể được kết hợp để cung cấp một phương pháp tiếp cận đa kiến ​​trúc vững chắc để lấy MSB. Giải pháp mà tôi đã đến để biên dịch / hoạt động trên các máy tính 64 & 32 bit là:

#if defined(__LP64__) || defined(_LP64)
# define BUILD_64   1
#endif

#include <stdio.h>
#include <stdint.h>  /* for uint32_t */

/* CHAR_BIT  (or include limits.h) */
#ifndef CHAR_BIT
#define CHAR_BIT  8
#endif  /* CHAR_BIT */

/* 
 * Find the log base 2 of an integer with the MSB N set in O(N)
 * operations. (on 64bit & 32bit architectures)
 */
int
getmsb (uint32_t word)
{
    int r = 0;
    if (word < 1)
        return 0;
#ifdef BUILD_64
    union { uint32_t u[2]; double d; } t;  // temp
    t.u[__FLOAT_WORD_ORDER==LITTLE_ENDIAN] = 0x43300000;
    t.u[__FLOAT_WORD_ORDER!=LITTLE_ENDIAN] = word;
    t.d -= 4503599627370496.0;
    r = (t.u[__FLOAT_WORD_ORDER==LITTLE_ENDIAN] >> 20) - 0x3FF;
#else
    while (word >>= 1)
    {
        r++;
    }
#endif  /* BUILD_64 */
    return r;
}

Một phiên bản trong C sử dụng phép gần đúng liên tiếp:

unsigned int getMsb(unsigned int n)
{
  unsigned int msb  = sizeof(n) * 4;
  unsigned int step = msb;
  while (step > 1)
 {
    step /=2;
    if (n>>msb)
     msb += step;
   else
     msb -= step;
 }
  if (n>>msb)
    msb++;
  return (msb - 1);
}

Ưu điểm: thời gian chạy không đổi bất kể số lượng được cung cấp, vì số lượng vòng lặp luôn bằng nhau. (4 vòng khi sử dụng "unsigned int")

Tôi biết câu hỏi này rất cũ, nhưng chỉ cần tự mình triển khai một hàm msb () , tôi thấy rằng hầu hết các giải pháp được trình bày ở đây và trên các trang web khác không nhất thiết là hiệu quả nhất - ít nhất là đối với định nghĩa của cá nhân tôi về hiệu quả (xem thêm Cập nhật bên dưới ). Đây là lý do tại sao:

Hầu hết các giải pháp (đặc biệt là những giải pháp sử dụng một số loại lược đồ tìm kiếm nhị phân hoặc cách tiếp cận ngây thơ quét tuyến tính từ phải sang trái) dường như bỏ qua thực tế rằng đối với các số nhị phân tùy ý, không có nhiều giải pháp bắt đầu bằng một chuỗi rất dài số không. Trên thực tế, đối với bất kỳ chiều rộng bit nào, một nửa số nguyên bắt đầu bằng 1 và một phần tư trong số chúng bắt đầu bằng 01 . Xem tôi đang ở đâu? Lập luận của tôi là quá trình quét tuyến tính bắt đầu từ vị trí bit quan trọng nhất đến ít quan trọng nhất (từ trái sang phải) không quá "tuyến tính" như thoạt nhìn có thể giống như vậy.

Có thể chỉ ra ¹ , rằng đối với bất kỳ độ rộng bit nào, số bit trung bình cần được kiểm tra nhiều nhất là 2. Điều này có nghĩa là độ phức tạp thời gian được phân bổ theo thời gian là O (1) đối với số bit (!) .

Tất nhiên, trường hợp xấu nhất vẫn là O (n) , tệ hơn là O (log (n)) mà bạn nhận được với các phương pháp tiếp cận giống như tìm kiếm nhị phân, nhưng vì có rất ít trường hợp xấu nhất nên chúng không đáng kể đối với hầu hết các ứng dụng ( Cập nhật : not khá: Có thể có ít, nhưng chúng có thể xảy ra với xác suất cao - xem Cập nhật bên dưới).

Đây là cách tiếp cận "ngây thơ" mà tôi đã đưa ra, ít nhất trên máy của tôi đánh bại hầu hết các cách tiếp cận khác (các lược đồ tìm kiếm nhị phân cho int 32 bit luôn yêu cầu log ₂ (32) = 5 bước, trong khi thuật toán ngớ ngẩn này yêu cầu ít hơn trung bình hơn 2) - xin lỗi vì đây là C ++ và không phải C thuần túy:

template <typename T>
auto msb(T n) -> int
{
    static_assert(std::is_integral<T>::value && !std::is_signed<T>::value,
        "msb<T>(): T must be an unsigned integral type.");

    for (T i = std::numeric_limits<T>::digits - 1, mask = 1 << i; i >= 0; --i, mask >>= 1)
    {
        if ((n & mask) != 0)
            return i;
    }

    return 0;
}

Cập nhật : Mặc dù những gì tôi đã viết ở đây hoàn toàn đúng với các số nguyên tùy ý , trong đó mọi sự kết hợp của các bit đều có thể xảy ra như nhau (kiểm tra tốc độ của tôi chỉ đơn giản là đo khoảng thời gian để xác định MSB cho). Trong trường hợp này, giải pháp của tôi thực sự sẽ hoạt động kém hơn so với cách tiếp cận tìm kiếm nhị phân - vì vậy cách tiếp cận sau có lẽ nên được ưu tiên hơn, mặc dù giải pháp của tôi sẽ lặp lại nhanh hơn qua tất cả các số nguyên. TL; DR: Các số nguyên trong đời thực có thể sẽ có xu hướng đối với trường hợp xấu nhất của thuật toán đơn giản này, điều này sẽ làm cho nó hoạt động kém hơn cuối cùng - mặc dù thực tế là nó được khấu hao tất cả các số nguyên 32 bit), số nguyên trong cuộc sống thực, cho mà một hàm như vậy sẽ được gọi, thường tuân theo một mẫu khác: Ví dụ: trong mã của tôi, hàm này được sử dụng để xác định xem kích thước đối tượng là lũy thừa của 2 hay để tìm lũy thừa tiếp theo của 2 lớn hơn hoặc bằng kích thước đối tượng . Tôi đoán rằng hầu hết các ứng dụng sử dụng MSB đều liên quan đến các số nhỏ hơn nhiều so với số tối đa mà một số nguyên có thể biểu diễn (kích thước đối tượng hiếm khi sử dụng tất cả các bit trong một size_t
O (1) cho các số nguyên thực sự tùy ý.

¹ Đối số như sau (bản nháp thô): Gọi n là số bit (chiều rộng bit). Có tổng cộng 2 ⁿ số nguyên có thể được biểu diễn bằng n bit. Có 2 ^{n - 1} số nguyên bắt đầu bằng 1 ( 1 đầu tiên là cố định, n - 1 bit còn lại có thể là bất kỳ thứ gì). Những số nguyên đó chỉ yêu cầu một số nguyên của vòng lặp để xác định MSB. Hơn nữa, có 2 ^{n - 2} số nguyên bắt đầu bằng 01 , yêu cầu 2 lần lặp, 2 ^{n - 3} số nguyên bắt đầu bằng 001 , yêu cầu 3 lần lặp, v.v.

Nếu chúng ta tính tổng tất cả các lần lặp cần thiết cho tất cả các số nguyên có thể và chia chúng cho 2 ⁿ , tổng số các số nguyên, chúng ta sẽ nhận được số lần lặp trung bình cần thiết để xác định MSB cho số nguyên n -bit:

(1 * 2 ^{n - 1} + 2 * 2 ^{n - 2} + 3 * 2 ^{n - 3} + ... + n) / 2 ⁿ

Chuỗi số lần lặp trung bình này thực sự là hội tụ và có giới hạn là 2 đối với n về phía vô hạn

Do đó, thuật toán từ trái sang phải ngây thơ thực sự có độ phức tạp theo thời gian không đổi được khấu hao là O (1) cho bất kỳ số bit nào.

c99đã cho chúng tôi log2. Điều này loại bỏ sự cần thiết của tất cả các log2triển khai nước sốt đặc biệt mà bạn thấy trên trang này. Bạn có thể sử dụng cách log2triển khai của tiêu chuẩn như sau:

const auto n = 13UL;
const auto Index = (unsigned long)log2(n);

printf("MSB is: %u\n", Index); // Prints 3 (zero offset)

Một ntrong những cũng 0ULcần phải được đề phòng, bởi vì:

-∞ được trả lại và FE_DIVBYZERO được nâng lên

Tôi đã viết một ví dụ với kiểm tra rằng bộ tùy tiện Indexđể ULONG_MAXở đây: https://ideone.com/u26vsi

Các Visual Studiohệ quả cho câu trả lời duy nhất của gcc là:

const auto n = 13UL;
unsigned long Index;

_BitScanReverse(&Index, n);
printf("MSB is: %u\n", Index); // Prints 3 (zero offset)

Tài liệu cho _BitScanReverse các trạng thái đó Indexlà:

Đã tải với vị trí bit của bit đặt đầu tiên (1) được tìm thấy

Trên thực tế tôi đã tìm thấy rằng nếu nlà 0ULđó Indexđược thiết lập để0UL , cũng giống như nó sẽ là một ntrong 1UL. Nhưng điều duy nhất được bảo đảm trong các tài liệu trong trường hợp của một nsố0UL là sự trở lại là:

0 nếu không tìm thấy bit đặt

Do đó, tương tự như việc log2triển khai thích hợp ở trên, trả về nên được kiểm tra cài đặt Indexthành giá trị được gắn cờ trong trường hợp này. Tôi lại viết một ví dụ về cách sử dụng ULONG_MAXcho giá trị cờ này tại đây: http://rextester.com/GCU61409

Hãy suy nghĩ các toán tử bitwise.

Tôi đã hiểu sai câu hỏi lần đầu tiên. Bạn nên tạo ra một int với tập bit ngoài cùng bên trái (các bit khác bằng 0). Giả sử cmp được đặt thành giá trị đó:

position = sizeof(int)*8
while(!(n & cmp)){ 
   n <<=1;
   position--;
}

Mở rộng trên điểm chuẩn của Josh ... người ta có thể cải thiện clz như sau

/***************** clz2 ********************/

#define NUM_OF_HIGHESTBITclz2(a) ((a)                              \
                  ? (((1U) << (sizeof(unsigned)*8-1)) >> __builtin_clz(a)) \
                  : 0)

Về asm: lưu ý là có bsr và bsrl (đây là bản "dài"). bình thường có thể nhanh hơn một chút.

Lưu ý rằng những gì bạn đang cố gắng làm là tính toán số nguyên log2 của một số nguyên,

#include <stdio.h>
#include <stdlib.h>

unsigned int
Log2(unsigned long x)
{
    unsigned long n = x;
    int bits = sizeof(x)*8;
    int step = 1; int k=0;
    for( step = 1; step < bits; ) {
        n |= (n >> step);
        step *= 2; ++k;
    }
    //printf("%ld %ld\n",x, (x - (n >> 1)) );
    return(x - (n >> 1));
}

Quan sát rằng bạn có thể cố gắng tìm kiếm nhiều hơn 1 bit cùng một lúc.

unsigned int
Log2_a(unsigned long x)
{
    unsigned long n = x;
    int bits = sizeof(x)*8;
    int step = 1;
    int step2 = 0;
    //observe that you can move 8 bits at a time, and there is a pattern...
    //if( x>1<<step2+8 ) { step2+=8;
        //if( x>1<<step2+8 ) { step2+=8;
            //if( x>1<<step2+8 ) { step2+=8;
            //}
        //}
    //}
    for( step2=0; x>1L<<step2+8; ) {
        step2+=8;
    }
    //printf("step2 %d\n",step2);
    for( step = 0; x>1L<<(step+step2); ) {
        step+=1;
        //printf("step %d\n",step+step2);
    }
    printf("log2(%ld) %d\n",x,step+step2);
    return(step+step2);
}

Cách tiếp cận này sử dụng tìm kiếm nhị phân

unsigned int
Log2_b(unsigned long x)
{
    unsigned long n = x;
    unsigned int bits = sizeof(x)*8;
    unsigned int hbit = bits-1;
    unsigned int lbit = 0;
    unsigned long guess = bits/2;
    int found = 0;

    while ( hbit-lbit>1 ) {
        //printf("log2(%ld) %d<%d<%d\n",x,lbit,guess,hbit);
        //when value between guess..lbit
        if( (x<=(1L<<guess)) ) {
           //printf("%ld < 1<<%d %ld\n",x,guess,1L<<guess);
            hbit=guess;
            guess=(hbit+lbit)/2;
            //printf("log2(%ld) %d<%d<%d\n",x,lbit,guess,hbit);
        }
        //when value between hbit..guess
        //else
        if( (x>(1L<<guess)) ) {
            //printf("%ld > 1<<%d %ld\n",x,guess,1L<<guess);
            lbit=guess;
            guess=(hbit+lbit)/2;
            //printf("log2(%ld) %d<%d<%d\n",x,lbit,guess,hbit);
        }
    }
    if( (x>(1L<<guess)) ) ++guess;
    printf("log2(x%ld)=r%d\n",x,guess);
    return(guess);
}

Một phương pháp tìm kiếm nhị phân khác, có lẽ dễ đọc hơn,

unsigned int
Log2_c(unsigned long x)
{
    unsigned long v = x;
    unsigned int bits = sizeof(x)*8;
    unsigned int step = bits;
    unsigned int res = 0;
    for( step = bits/2; step>0; )
    {
        //printf("log2(%ld) v %d >> step %d = %ld\n",x,v,step,v>>step);
        while ( v>>step ) {
            v>>=step;
            res+=step;
            //printf("log2(%ld) step %d res %d v>>step %ld\n",x,step,res,v);
        }
        step /= 2;
    }
    if( (x>(1L<<res)) ) ++res;
    printf("log2(x%ld)=r%ld\n",x,res);
    return(res);
}

Và bởi vì bạn sẽ muốn kiểm tra những điều này,

int main()
{
    unsigned long int x = 3;
    for( x=2; x<1000000000; x*=2 ) {
        //printf("x %ld, x+1 %ld, log2(x+1) %d\n",x,x+1,Log2(x+1));
        printf("x %ld, x+1 %ld, log2_a(x+1) %d\n",x,x+1,Log2_a(x+1));
        printf("x %ld, x+1 %ld, log2_b(x+1) %d\n",x,x+1,Log2_b(x+1));
        printf("x %ld, x+1 %ld, log2_c(x+1) %d\n",x,x+1,Log2_c(x+1));
    }
    return(0);
}

Đưa điều này vào vì nó là một cách tiếp cận 'chưa khác', có vẻ khác với những cách khác đã được đưa ra.

trả về -1nếu x==0, nếu không floor( log2(x)) (kết quả tối đa 31)

Giảm vấn đề từ 32 xuống 4 bit, sau đó sử dụng một bảng. Có lẽ không lịch sự, nhưng thực dụng.

Đây là những gì tôi sử dụng khi tôi không muốn sử dụng __builtin_clzvì các vấn đề về tính di động.

Để làm cho nó nhỏ gọn hơn, thay vào đó, người ta có thể sử dụng một vòng lặp để giảm bớt, thêm 4 thành r mỗi lần, tối đa 7 lần lặp. Hoặc một số kết hợp, chẳng hạn như (cho 64 bit): vòng lặp để giảm xuống 8, kiểm tra để giảm xuống 4.

int log2floor( unsigned x ){
   static const signed char wtab[16] = {-1,0,1,1, 2,2,2,2, 3,3,3,3,3,3,3,3};
   int r = 0;
   unsigned xk = x >> 16;
   if( xk != 0 ){
       r = 16;
       x = xk;
   }
   // x is 0 .. 0xFFFF
   xk = x >> 8;
   if( xk != 0){
       r += 8;
       x = xk;
   }
   // x is 0 .. 0xFF
   xk = x >> 4;
   if( xk != 0){
       r += 4;
       x = xk;
   }
   // now x is 0..15; x=0 only if originally zero.
   return r + wtab[x];
}

Woaw, đó là nhiều câu trả lời. Tôi không xin lỗi vì đã trả lời một câu hỏi cũ.

int result = 0;//could be a char or int8_t instead
if(value){//this assumes the value is 64bit
    if(0xFFFFFFFF00000000&value){  value>>=(1<<5); result|=(1<<5);  }//if it is 32bit then remove this line
    if(0x00000000FFFF0000&value){  value>>=(1<<4); result|=(1<<4);  }//and remove the 32msb
    if(0x000000000000FF00&value){  value>>=(1<<3); result|=(1<<3);  }
    if(0x00000000000000F0&value){  value>>=(1<<2); result|=(1<<2);  }
    if(0x000000000000000C&value){  value>>=(1<<1); result|=(1<<1);  }
    if(0x0000000000000002&value){  result|=(1<<0);  }
}else{
  result=-1;
}

Câu trả lời này khá giống với một câu trả lời khác ... ồ ồ.

Mật mã:

    // x>=1;
    unsigned func(unsigned x) {
    double d = x ;
    int p= (*reinterpret_cast<long long*>(&d) >> 52) - 1023;
    printf( "The left-most non zero bit of %d is bit %d\n", x, p);
    }

Hoặc lấy phần nguyên của lệnh FPU FYL2X (Y * Log2 X) bằng cách đặt Y = 1

Một người đăng khác đã cung cấp một bảng tra cứu bằng cách sử dụng tra cứu toàn byte . Trong trường hợp bạn muốn tăng hiệu suất hơn một chút (với chi phí 32K bộ nhớ thay vì chỉ 256 mục tra cứu), đây là một giải pháp sử dụng bảng tra cứu 15 bit , trong C # 7 cho .NET .

Phần thú vị là khởi tạo bảng. Vì đó là một khối tương đối nhỏ mà chúng tôi muốn trong suốt thời gian tồn tại của quá trình, tôi phân bổ bộ nhớ không được quản lý cho khối này bằng cách sử dụng Marshal.AllocHGlobal. Như bạn có thể thấy, để có hiệu suất tối đa, toàn bộ ví dụ được viết dưới dạng gốc:

readonly static byte[] msb_tab_15;

// Initialize a table of 32768 bytes with the bit position (counting from LSB=0)
// of the highest 'set' (non-zero) bit of its corresponding 16-bit index value.
// The table is compressed by half, so use (value >> 1) for indexing.
static MyStaticInit()
{
    var p = new byte[0x8000];

    for (byte n = 0; n < 16; n++)
        for (int c = (1 << n) >> 1, i = 0; i < c; i++)
            p[c + i] = n;

    msb_tab_15 = p;
}

Bảng yêu cầu khởi tạo một lần qua đoạn mã trên. Nó ở chế độ chỉ đọc nên một bản sao chung duy nhất có thể được chia sẻ để truy cập đồng thời. Với bảng này, bạn có thể nhanh chóng tra cứu nhật ký số nguyên ₂ , đó là những gì chúng tôi đang tìm kiếm ở đây, cho tất cả các độ rộng số nguyên khác nhau (8, 16, 32 và 64 bit).

Lưu ý rằng mục nhập bảng 0, số nguyên duy nhất mà khái niệm 'bit đặt cao nhất' không được xác định, được cung cấp giá trị -1. Sự phân biệt này là cần thiết để xử lý thích hợp các từ trên có giá trị 0 trong đoạn mã dưới đây. Không cần thêm lời khuyên nào nữa, đây là mã cho từng số nguyên gốc khác nhau:

Phiên bản ulong (64-bit)

/// <summary> Index of the highest set bit in 'v', or -1 for value '0' </summary>
public static int HighestOne(this ulong v)
{
    if ((long)v <= 0)
        return (int)((v >> 57) & 0x40) - 1;      // handles cases v==0 and MSB==63

    int j = /**/ (int)((0xFFFFFFFFU - v /****/) >> 58) & 0x20;
    j |= /*****/ (int)((0x0000FFFFU - (v >> j)) >> 59) & 0x10;
    return j + msb_tab_15[v >> (j + 1)];
}

Phiên bản uint (32-bit)

/// <summary> Index of the highest set bit in 'v', or -1 for value '0' </summary>
public static int HighestOne(uint v)
{
    if ((int)v <= 0)
        return (int)((v >> 26) & 0x20) - 1;     // handles cases v==0 and MSB==31

    int j = (int)((0x0000FFFFU - v) >> 27) & 0x10;
    return j + msb_tab_15[v >> (j + 1)];
}

Quá tải khác nhau cho những điều trên

public static int HighestOne(long v) => HighestOne((ulong)v);
public static int HighestOne(int v) => HighestOne((uint)v);
public static int HighestOne(ushort v) => msb_tab_15[v >> 1];
public static int HighestOne(short v) => msb_tab_15[(ushort)v >> 1];
public static int HighestOne(char ch) => msb_tab_15[ch >> 1];
public static int HighestOne(sbyte v) => msb_tab_15[(byte)v >> 1];
public static int HighestOne(byte v) => msb_tab_15[v >> 1];

Đây là một giải pháp hoàn chỉnh, hoạt động, thể hiện hiệu suất tốt nhất trên .NET 4.7.2 cho nhiều lựa chọn thay thế mà tôi đã so sánh với khai thác kiểm tra hiệu suất chuyên dụng. Một số trong số này được đề cập dưới đây. Các tham số thử nghiệm là mật độ đồng nhất của tất cả các vị trí 65 bit, tức là, giá trị cộng 0 ... 31/630 (tạo ra kết quả -1). Các bit bên dưới vị trí chỉ mục đích được điền ngẫu nhiên. Các thử nghiệm chỉ là x64 , chế độ phát hành, với tính năng tối ưu hóa JIT được bật.

Đó là phần cuối của câu trả lời chính thức của tôi ở đây; sau đây là một số ghi chú thông thường và liên kết đến mã nguồn cho các ứng cử viên thử nghiệm thay thế được liên kết với thử nghiệm tôi đã chạy để xác thực hiệu suất và tính đúng đắn của mã trên.

Phiên bản được cung cấp ở trên, được mã hóa là Tab16A là phiên bản chiến thắng nhất quán qua nhiều lần chạy. Các ứng viên khác nhau này, ở dạng làm việc tích cực / dạng cào, có thể được tìm thấy tại đây , tại đây và tại đây .

 1 ứng cử viên.HighestOne_Tab16A 622.496
 2 ứng cử viên.HighestOne_Tab16C 628,234
 3 ứng cử viên.HighestOne_Tab8A 649,146
 4 ứng cử viên.HighestOne_Tab8B 656,847
 5 ứng cử viên.HighestOne_Tab16B 657,147
 6 ứng cử viên.HighestOne_Tab16D 659,650
 7 _highest_one_bit_UNMANAGED.HighestOne_U 702,900
 8 de_Bruijn.IndexOfMSB 709,672
 9 _old_2.HighestOne_Old2 715,810
10 _test_A.HighestOne8 757,188
11 _old_1.HighestOne_Old1 757,925
12 _test_A.HighestOne5 (không an toàn) 760,387
13 _test_B.HighestOne8 (không an toàn) 763.904
14 _test_A.HighestOne3 (không an toàn) 766,433
15 _test_A.HighestOne1 (không an toàn) 767,321
16 _test_A.HighestOne4 (không an toàn) 771.702
17 _test_B.HighestOne2 (không an toàn) 772,136
18 _test_B.HighestOne1 (không an toàn) 772,527
19 _test_B.HighestOne3 (không an toàn) 774,140
20 _test_A.HighestOne7 (không an toàn) 774,581
21 _test_B.HighestOne7 (không an toàn) 775,463
22 _test_A.HighestOne2 (không an toàn) 776,865
23 ứng cử viên.HighestOne_NoTab 777,698
24 _test_B.HighestOne6 (không an toàn) 779,481
25 _test_A.HighestOne6 (không an toàn) 781,553
26 _test_B.HighestOne4 (không an toàn) 785,504
27 _test_B.HighestOne5 (không an toàn) 789,797
28 _test_A.HighestOne0 (không an toàn) 809,566
29 _test_B.HighestOne0 (không an toàn) 814,990
30 _highest_one_bit.HighestOne 824.345
30 _bitarray_ext.RtlFindMostSignificantBit 894.069
31 ứng cử viên.HighestOne_Naive 898,865

Đáng chú ý là hiệu suất khủng khiếp của ntdll.dll!RtlFindMostSignificantBitthông qua P / Invoke:

[DllImport("ntdll.dll"), SuppressUnmanagedCodeSecurity, SecuritySafeCritical]
public static extern int RtlFindMostSignificantBit(ulong ul);

Nó thực sự quá tệ, bởi vì đây là toàn bộ chức năng thực tế:

    RtlFindMostSignificantBit:
        bsr rdx, rcx  
        mov eax,0FFFFFFFFh  
        movzx ecx, dl  
        cmovne      eax,ecx  
        ret

Tôi không thể tưởng tượng được hiệu suất kém bắt nguồn từ năm dòng này, vì vậy các hình phạt chuyển đổi được quản lý / bản địa phải là nguyên nhân. Tôi cũng ngạc nhiên rằng thử nghiệm thực sự ưu tiên các shortbảng tra cứu trực tiếp 32KB (và 64KB) (16-bit) hơn các bảng tra cứu 128 byte (và 256-byte) byte(8-bit). Tôi nghĩ phần sau sẽ cạnh tranh hơn với các tra cứu 16 bit, nhưng phần sau luôn làm tốt hơn điều này:

public static int HighestOne_Tab8A(ulong v)
{
    if ((long)v <= 0)
        return (int)((v >> 57) & 64) - 1;

    int j;
    j =  /**/ (int)((0xFFFFFFFFU - v) >> 58) & 32;
    j += /**/ (int)((0x0000FFFFU - (v >> j)) >> 59) & 16;
    j += /**/ (int)((0x000000FFU - (v >> j)) >> 60) & 8;
    return j + msb_tab_8[v >> j];
}

Điều cuối cùng tôi sẽ chỉ ra là tôi khá sốc khi phương pháp deBruijn của tôi không tốt hơn. Đây là phương pháp mà trước đây tôi đã sử dụng phổ biến:

const ulong N_bsf64 = 0x07EDD5E59A4E28C2,
            N_bsr64 = 0x03F79D71B4CB0A89;

readonly public static sbyte[]
bsf64 =
{
    63,  0, 58,  1, 59, 47, 53,  2, 60, 39, 48, 27, 54, 33, 42,  3,
    61, 51, 37, 40, 49, 18, 28, 20, 55, 30, 34, 11, 43, 14, 22,  4,
    62, 57, 46, 52, 38, 26, 32, 41, 50, 36, 17, 19, 29, 10, 13, 21,
    56, 45, 25, 31, 35, 16,  9, 12, 44, 24, 15,  8, 23,  7,  6,  5,
},
bsr64 =
{
     0, 47,  1, 56, 48, 27,  2, 60, 57, 49, 41, 37, 28, 16,  3, 61,
    54, 58, 35, 52, 50, 42, 21, 44, 38, 32, 29, 23, 17, 11,  4, 62,
    46, 55, 26, 59, 40, 36, 15, 53, 34, 51, 20, 43, 31, 22, 10, 45,
    25, 39, 14, 33, 19, 30,  9, 24, 13, 18,  8, 12,  7,  6,  5, 63,
};

public static int IndexOfLSB(ulong v) =>
    v != 0 ? bsf64[((v & (ulong)-(long)v) * N_bsf64) >> 58] : -1;

public static int IndexOfMSB(ulong v)
{
    if ((long)v <= 0)
        return (int)((v >> 57) & 64) - 1;

    v |= v >> 1; v |= v >> 2;  v |= v >> 4;   // does anybody know a better
    v |= v >> 8; v |= v >> 16; v |= v >> 32;  // way than these 12 ops?
    return bsr64[(v * N_bsr64) >> 58];
}