Qual é a maneira mais rápida / eficiente de encontrar o bit de conjunto mais alto (msb) em um inteiro em C?

Se eu tiver algum número inteiro n e quiser saber a posição do bit mais significativo (ou seja, se o bit menos significativo estiver à direita, quero saber a posição do bit mais à esquerda que é 1), qual é o método mais rápido / eficiente de descobrir?

Eu sei que POSIX oferece suporte a um ffs()método em strings.h para encontrar o primeiro conjunto de bits, mas não parece haver um fls()método correspondente .

Existe alguma maneira realmente óbvia de fazer isso que estou perdendo?

E nos casos em que você não pode usar funções POSIX para portabilidade?

Edit: Que tal uma solução que funciona em arquiteturas de 32 e 64 bits (muitas das listagens de código parecem que só funcionam em ints de 32 bits).

GCC tem :

 - Função interna: int __builtin_clz (unsigned int x)
     Retorna o número de bits 0 iniciais em X, começando no máximo
     posição significativa do bit. Se X for 0, o resultado é indefinido.

 - Função integrada: int __builtin_clzl (não assinado longo)
     Semelhante a `__builtin_clz ', exceto que o tipo de argumento é` sem sinal
     longo'.

 - Função integrada: int __builtin_clzll (unsigned long long)
     Semelhante a `__builtin_clz ', exceto que o tipo de argumento é` sem sinal
     longo longo'.

Eu esperaria que eles fossem traduzidos em algo razoavelmente eficiente para sua plataforma atual, seja um daqueles algoritmos sofisticados de bit-twiddling ou uma única instrução.

Um truque útil se a sua entrada pode ser zero é __builtin_clz(x | 1): incondicionalmente definindo o baixo bit sem modificar quaisquer outros faz com que a saída 31para x=0, sem alterar a saída para qualquer outra entrada.

Para evitar a necessidade de fazer isso, sua outra opção são intrínsecos específicos da plataforma, como ARM GCC __clz(nenhum cabeçalho necessário) ou x86 _lzcnt_u32em CPUs que suportam a lzcntinstrução. (Cuidado com isso lzcntdecodifica como bsrem CPUs mais antigas em vez de falhas, o que dá 31-lzcnt para entradas diferentes de zero.)

Infelizmente, não há como aproveitar as vantagens das várias instruções CLZ em plataformas não x86 que definem o resultado para input = 0 como 32 ou 64 (de acordo com a largura do operando). O x86 também lzcntfaz isso, enquanto bsrproduz um índice de bits que o compilador deve inverter a menos que você use 31-__builtin_clz(x).

(O "resultado indefinido" não é C Undefined Behavior, apenas um valor que não está definido. É na verdade tudo o que estava no registro de destino quando a instrução foi executada. AMD documenta isso, Intel não, mas CPUs da Intel implementam esse comportamento . Mas ele não o que estava anteriormente na variável C você está atribuindo a, isso não é geralmente como as coisas funcionam quando gcc transforma C em asm. Veja também por que quebrar a "saída de dependência" de LZCNT importa? )

Supondo que você esteja no x86 e jogo para um pouco de montador embutido, a Intel fornece uma BSRinstrução ("varredura reversa de bits"). É rápido em alguns x86s (microcodificado em outros). Do manual:

Pesquisa o operando de origem para o bit definido mais significativo (1 bit). Se um bit 1 mais significativo for encontrado, seu índice de bit é armazenado no operando de destino. O operando de origem pode ser um registro ou um local de memória; o operando de destino é um registrador. O índice de bits é um deslocamento sem sinal do bit 0 do operando de origem. Se o operando fonte de conteúdo for 0, o conteúdo do operando destino é indefinido.

(Se você estiver no PowerPC, há uma cntlzinstrução semelhante ("contar zeros à esquerda").)

Código de exemplo para 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;
}

Veja também este tutorial de assembler embutido , que mostra (seção 9.4) que ele é consideravelmente mais rápido do que código em loop.

Como 2 ^ N é um número inteiro com apenas o enésimo bit definido (1 << N), encontrar a posição (N) do bit mais alto é o log de número inteiro de base 2 desse inteiro.

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

unsigned int v;
unsigned r = 0;

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

Este algoritmo "óbvio" pode não ser transparente para todos, mas quando você percebe que o código muda um bit repetidamente para a direita até que o bit mais à esquerda seja deslocado (observe que C trata qualquer valor diferente de zero como verdadeiro) e retorna o número de turnos, faz todo o sentido. Também significa que funciona mesmo quando mais de um bit é definido - o resultado é sempre para o bit mais significativo.

Se você rolar para baixo nessa página, verá variações mais rápidas e complexas. No entanto, se você sabe que está lidando com números com muitos zeros à esquerda, a abordagem ingênua pode fornecer uma velocidade aceitável, uma vez que o deslocamento de bits é bastante rápido em C e o algoritmo simples não requer a indexação de um array.

NOTA: Ao usar valores de 64 bits, seja extremamente cauteloso ao usar algoritmos muito inteligentes; muitos deles funcionam corretamente apenas para valores de 32 bits.

Isso deve ser rápido:

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];
}

Isso é como encontrar um tipo de log de inteiro. Existem pequenos truques, mas fiz minha própria ferramenta para isso. O objetivo, é claro, é velocidade.

Minha constatação é que a CPU já tem um detector automático de bits, usado para conversão de inteiro para float! Então use isso.

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

Essa versão converte o valor em um duplo e, em seguida, lê o expoente, que informa onde o bit estava. A mudança e subtração extravagantes são extrair as partes adequadas do valor IEEE.

É um pouco mais rápido usar floats, mas um float só pode fornecer as primeiras posições de 24 bits por causa de sua precisão menor.

Para fazer isso com segurança, sem comportamento indefinido em C ++ ou C, use em memcpyvez de conversão de ponteiro para trocadilhos. Os compiladores sabem como embuti-lo de forma eficiente.

// 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;

Ou em C99 e posterior, use a union {double d; uint32_t u[2];};. Mas note que em C ++, o tipo de união punning só é suportado em alguns compiladores como uma extensão, não em ISO C ++.

Isso geralmente será mais lento do que um intrínseco específico de plataforma para uma instrução de contagem de zeros à esquerda, mas o ISO C portátil não tem essa função. Algumas CPUs também carecem de uma instrução de contagem zero à esquerda, mas algumas delas podem converter números inteiros em com eficiência double. A conversão de um padrão de bit FP de volta para um inteiro pode ser lenta, porém (por exemplo, no PowerPC, isso requer um armazenamento / recarregamento e geralmente causa um bloqueio de carregamento, acerto e armazenamento).

Este algoritmo pode ser potencialmente útil para implementações SIMD, porque menos CPUs têm SIMD lzcnt. x86 só obteve tal instrução com AVX512CD

Kaz Kylheku aqui

Eu comparei duas abordagens para este número de mais de 63 bits (o tipo long long no gcc x86_64), ficando longe do bit de sinal.

(Acontece que preciso deste "encontrar o bit mais alto" para algo, você vê.)

Implementei a pesquisa binária baseada em dados (estritamente baseada em uma das respostas acima). Eu também implementei uma árvore de decisão completamente desenrolada manualmente, que é apenas um código com operandos imediatos. Sem loops, sem tabelas.

A árvore de decisão (higher_bit_unrolled) foi avaliada como 69% mais rápida, exceto para o caso n = 0 para o qual a pesquisa binária tem um teste explícito.

O teste especial da busca binária para 0 caso é apenas 48% mais rápido do que a árvore de decisão, que não tem um teste especial.

Compilador, máquina: (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;
}

Programa de teste rápido e sujo:

#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;
}

Usando apenas -O2, a diferença se torna maior. A árvore de decisão é quase quatro vezes mais rápida.

Eu também comparei com o código ingênuo de mudança de bits:

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

Isso é rápido apenas para números pequenos, como seria de esperar. Ao determinar que o bit mais alto é 1 para n == 1, fez o benchmarking mais de 80% mais rápido. No entanto, metade dos números escolhidos aleatoriamente no espaço de 63 bits têm o conjunto de 63 bits!

Na entrada 0x3FFFFFFFFFFFFFFF, a versão da árvore de decisão é um pouco mais rápida do que em 1 e mostra ser 1120% mais rápida (12,2 vezes) do que o bit shifter.

Também vou comparar a árvore de decisão com os builtins do GCC e também tentar uma mistura de entradas em vez de repetir com o mesmo número. Pode haver alguma previsão de branch travado acontecendo e talvez alguns cenários de cache irrealistas que o tornam artificialmente mais rápido nas repetições.

A respeito

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 registro, 13 instruções. Acredite ou não, isso geralmente é mais rápido do que a instrução BSR mencionada acima, que opera em tempo linear. Este é o tempo logarítmico.

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

Aqui estão alguns benchmarks (simples) de algoritmos fornecidos atualmente nesta página ...

Os algoritmos não foram testados em todas as entradas de int sem sinal; então verifique isso primeiro, antes de usar algo às cegas;)

Na minha máquina, clz (__builtin_clz) e asm funcionam melhor. asm parece ainda mais rápido do que clz ... mas pode ser devido ao benchmark simples ...

//////// 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;
}

Embora eu provavelmente só usasse esse método se absolutamente exigisse o melhor desempenho possível (por exemplo, para escrever algum tipo de IA de jogo de tabuleiro envolvendo quadros de bits), a solução mais eficiente é usar o ASM embutido. Consulte a seção Otimizações desta postagem do blog para obter o código com uma explicação.

[...], a bsrlinstrução de montagem calcula a posição do bit mais significativo. Assim, poderíamos usar esta asmdeclaração:

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

Eu precisava de uma rotina para fazer isso e antes de pesquisar na web (e encontrar esta página), criei minha própria solução baseada em uma pesquisa binária. Embora eu tenha certeza de que alguém já fez isso antes! Ele roda em tempo constante e pode ser mais rápido do que a solução "óbvia" postada, embora eu não esteja fazendo grandes afirmações, apenas postando por interesse.

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;
}

isso é algum tipo de pesquisa binária, funciona com todos os tipos de inteiros (sem sinal!)

#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;
}

para completar:

#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;
}

Algumas respostas excessivamente complexas aqui. A técnica Debruin só deve ser usada quando a entrada já é uma potência de dois, caso contrário, há uma maneira melhor. Para uma potência de 2 entradas, o Debruin é o mais rápido absoluto, ainda mais rápido do que _BitScanReverseem qualquer processador que testei. No entanto, no caso geral,_BitScanReverse (ou qualquer que seja o nome do intrínseco em seu compilador) é o mais rápido (embora em certas CPUs ele possa ser microcodificado).

Se a função intrínseca não for uma opção, aqui está uma solução de software ideal para processar entradas gerais.

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;
}

Observe que esta versão não requer uma consulta de Debruin no final, ao contrário da maioria das outras respostas. Ele calcula a posição no lugar.

As tabelas podem ser preferíveis, no entanto, se você chamá-las repetidamente o suficiente, o risco de uma falha de cache será eclipsado pelo aumento da velocidade de uma tabela.

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;
}

Isso deve produzir o maior rendimento de qualquer uma das respostas de software fornecidas aqui, mas se você apenas ligar ocasionalmente, prefira uma solução livre de tabela como meu primeiro trecho.

Como as respostas acima indicam, há várias maneiras de determinar o bit mais significativo. No entanto, como também foi apontado, os métodos provavelmente serão exclusivos para registradores de 32 ou 64 bits. A página stanford.edu bithacks fornece soluções que funcionam para computação de 32 bits e 64 bits. Com um pouco de trabalho, eles podem ser combinados para fornecer uma abordagem sólida de arquitetura cruzada para obter o MSB. A solução que cheguei para compilar / trabalhar em computadores de 64 e 32 bits foi:

#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;
}

Uma versão em C usando aproximação sucessiva:

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);
}

Vantagem: o tempo de execução é constante independentemente do número fornecido, pois o número de loops é sempre o mesmo. (4 loops ao usar "unsigned int")

Eu sei que esta questão é muito antiga, mas apenas tendo implementado uma função msb () eu mesmo descobri que a maioria das soluções apresentadas aqui e em outros sites não são necessariamente as mais eficientes - pelo menos para minha definição pessoal de eficiência (veja também Atualização abaixo ) Aqui está o porquê:

A maioria das soluções (especialmente aquelas que empregam algum tipo de esquema de busca binária ou a abordagem ingênua que faz uma varredura linear da direita para a esquerda) parecem negligenciar o fato de que, para números binários arbitrários, não há muitos que começam com uma sequência muito longa de zeros. Na verdade, para qualquer largura de bit, metade de todos os inteiros começam com 1 e um quarto deles começam com 01 . Veja onde estou chegando? Meu argumento é que uma varredura linear começando da posição do bit mais significativo para o menos significativo (da esquerda para a direita) não é tão "linear" como pode parecer à primeira vista.

Pode ser mostrado ¹ , que para qualquer largura de bit, o número médio de bits que precisam ser testados é no máximo 2. Isso se traduz em uma complexidade de tempo amortizado de O (1) em relação ao número de bits (!) .

Claro, o pior caso ainda é O (n) , pior do que o O (log (n)) que você obtém com abordagens do tipo busca binária, mas como há tão poucos casos piores, eles são insignificantes para a maioria dos aplicativos ( Atualizar : não é bem assim: pode haver poucos, mas podem ocorrer com alta probabilidade - consulte a atualização abaixo).

Aqui está a abordagem "ingênua" que criei, que pelo menos na minha máquina supera a maioria das outras abordagens (esquemas de pesquisa binária para ints de 32 bits sempre requerem log ₂ (32) = 5 etapas, enquanto este algoritmo bobo requer menos de 2 em média) - desculpe por ser C ++ e não C puro:

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;
}

Atualização : Embora o que escrevi aqui seja perfeitamente verdadeiro parainteiros arbitrários , onde cada combinação de bits é igualmente provável (meu teste de velocidade simplesmente mediu quanto tempo levou para determinar o MSB para todos os inteiros de 32 bits), inteiros da vida real, para que tal função será chamada, geralmente segue um padrão diferente: No meu código, por exemplo, esta função é usada para determinar se o tamanho de um objeto é uma potência de 2, ou para encontrar a próxima potência de 2 maior ou igual a um tamanho do objeto . Meu palpite é que a maioria dos aplicativos que usam o MSB envolvem números que são muito menores do que o número máximo que um inteiro pode representar (os tamanhos dos objetos raramente utilizam todos os bits em um size_t) Nesse caso, minha solução terá um desempenho pior do que uma abordagem de pesquisa binária - então, a última provavelmente deve ser preferida, embora minha solução seja um loop mais rápido por todos os inteiros.
TL; DR: Os inteiros da vida real provavelmente terão uma tendência para o pior caso desse algoritmo simples, o que tornará seu desempenho pior no final - apesar do fato de ser O (1) amortizado para inteiros verdadeiramente arbitrários.

¹ O argumento é assim (rascunho): Seja n o número de bits (largura de bits). Há um total de 2 ⁿ inteiros que podem ser representados com n bits. Existem 2 ^{n - 1} inteiros começando com 1 (o primeiro 1 é fixo, os n - 1 bits restantes podem ser qualquer coisa). Esses inteiros requerem apenas uma interação do loop para determinar o MSB. Além disso, há 2 ^{n - 2} inteiros começando com 01 , exigindo 2 iterações, 2 ^{n - 3} inteiros começando com 001 , exigindo 3 iterações e assim por diante.

Se somarmos todas as iterações necessárias para todos os inteiros possíveis e dividi-los por 2 ⁿ , o número total de inteiros, obtemos o número médio de iterações necessárias para determinar o MSB para inteiros de n bits:

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

Esta série de iterações médias é convergente e tem um limite de 2 para n até o infinito

Assim, o algoritmo ingênuo da esquerda para a direita tem, na verdade, uma complexidade de tempo constante amortizada de O (1) para qualquer número de bits.

c99nos deu log2. Isso elimina a necessidade de todas as log2implementações de molhos especiais que você vê nesta página. Você pode usar a log2implementação do padrão assim:

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

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

Um nde 0ULprecisa ser evitado também, porque:

-∞ é retornado e FE_DIVBYZERO é gerado

Eu escrevi um exemplo com esse cheque que é definido arbitrariamente Indexcomo ULONG_MAXaqui: https://ideone.com/u26vsi

o estúdio visualo corolário da única resposta gcc do efemiente é:

const auto n = 13UL;
unsigned long Index;

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

A documentação para_BitScanReverse estados que Indexsão:

Carregado com a posição do bit do primeiro conjunto de bits (1) encontrado

Na prática, eu descobri que, se né 0ULque Indexestá definido para0UL , assim como seria para um nde 1UL. Mas a única coisa garantida na documentação no caso de um nde 0ULé que a devolução é:

0 se nenhum conjunto de bits foi encontrado

Assim, de forma semelhante à log2implementação preferencial acima, o retorno deve ser verificado definindo Indexum valor sinalizado neste caso. Novamente escrevi um exemplo de uso ULONG_MAXpara este valor de sinalizador aqui: http://rextester.com/GCU61409

Pense em operadores bit a bit.

Eu não entendi a pergunta da primeira vez. Você deve produzir um int com o conjunto de bits mais à esquerda (os outros zero). Supondo que cmp esteja definido com esse valor:

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

Expandindo o benchmark de Josh ... pode-se melhorar o CLZ da seguinte maneira

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

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

Com relação ao asm: observe que existem bsr e bsrl (esta é a versão "longa"). o normal pode ser um pouco mais rápido.

Observe que o que você está tentando fazer é calcular o inteiro log2 de um inteiro,

#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));
}

Observe que você pode tentar pesquisar mais de 1 bit por vez.

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);
}

Esta abordagem usa uma pesquisa binária

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);
}

Outro método de pesquisa binária, talvez mais legível,

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);
}

E porque você vai querer testá-los,

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);
}

Colocar isso, visto que é "mais uma" abordagem, parece ser diferente de outras já fornecidas.

retorna -1if x==0, caso contrário floor( log2(x)) (resultado máximo 31)

Reduza o problema de 32 para 4 bits e, em seguida, use uma tabela. Talvez deselegante, mas pragmático.

É o que eu uso quando não quero usar __builtin_clzdevido a problemas de portabilidade.

Para torná-lo mais compacto, pode-se usar um loop para reduzir, adicionando 4 a r de cada vez, no máximo 7 iterações. Ou algum híbrido, como (para 64 bits): loop para reduzir para 8, teste para reduzir para 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];
}

Uau, foram muitas as respostas. Não lamento responder a uma pergunta antiga.

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;
}

Esta resposta é muito semelhante a outra resposta ... tudo bem.

O código:

    // 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);
    }

Ou obtenha a parte inteira da instrução FPU FYL2X (Y * Log2 X) configurando Y = 1

Outro pôster forneceu uma tabela de consulta usando uma consulta de todos os bytes . Caso você queira obter um pouco mais de desempenho (ao custo de 32K de memória em vez de apenas 256 entradas de pesquisa), aqui está uma solução usando uma tabela de pesquisa de 15 bits , em C # 7 para .NET .

A parte interessante é inicializar a tabela. Como é um bloco relativamente pequeno que queremos durante o tempo de vida do processo, aloco memória não gerenciada para isso usando Marshal.AllocHGlobal. Como você pode ver, para desempenho máximo, todo o exemplo é escrito como nativo:

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;
}

A tabela requer inicialização única por meio do código acima. É somente leitura, portanto, uma única cópia global pode ser compartilhada para acesso simultâneo. Com esta tabela, você pode consultar rapidamente o log ₂ do inteiro , que é o que estamos procurando aqui, para todas as várias larguras de inteiro (8, 16, 32 e 64 bits).

Observe que a entrada da tabela para 0, o único inteiro para o qual a noção de 'bit de conjunto mais alto' é indefinido, recebe o valor -1. Essa distinção é necessária para o tratamento adequado de palavras superiores com valor 0 no código a seguir. Sem mais delongas, aqui está o código para cada um dos vários primitivos inteiros:

versão ulong (64 bits)

/// <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)];
}

Versão uint (32 bits)

/// <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)];
}

Várias sobrecargas para o acima

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];

Esta é uma solução completa e funcional que representa o melhor desempenho no .NET 4.7.2 para inúmeras alternativas que comparei com um equipamento de teste de desempenho especializado. Alguns deles são mencionados abaixo. Os parâmetros de teste foram uma densidade uniforme de todas as posições de 65 bits, ou seja, 0 ... 31/63 mais o valor 0(que produz o resultado -1). Os bits abaixo da posição do índice de destino foram preenchidos aleatoriamente. Os testes foram x64 apenas , modo de lançamento, com otimizações JIT habilitadas.

Esse é o fim da minha resposta formal aqui; o que se segue são algumas notas casuais e links para o código-fonte para candidatos de teste alternativos associados ao teste que executei para validar o desempenho e a exatidão do código acima.

A versão fornecida acima, codificada como Tab16A, foi uma vencedora consistente em muitas execuções. Esses vários candidatos, em forma ativa de trabalho / scratch, podem ser encontrados aqui , aqui e aqui .

 1 candidatos. HighestOne_Tab16A 622.496
 2 candidatos. HighestOne_Tab16C 628.234
 3 candidatos.HighestOne_Tab8A 649.146
 4 candidatos. HighestOne_Tab8B 656.847
 5 candidatos. HighestOne_Tab16B 657.147
 6 candidatos. 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 (inseguro) 760.387
13 _teste_B.HighestOne8 (inseguro) 763.904
14 _test_A.HighestOne3 (inseguro) 766.433
15 _test_A.HighestOne1 (inseguro) 767.321
16 _teste_A.HighestOne4 (inseguro) 771.702
17 _teste_B.HighestOne2 (inseguro) 772.136
18 _test_B.HighestOne1 (inseguro) 772.527
19 _teste_B.HighestOne3 (inseguro) 774.140
20 _test_A.HighestOne7 (inseguro) 774.581
21 _test_B.HighestOne7 (inseguro) 775.463
22 _test_A.HighestOne2 (inseguro) 776.865
23 candidatos. HighestOne_NoTab 777.698
24 _test_B.HighestOne6 (inseguro) 779.481
25 _test_A.HighestOne6 (inseguro) 781.553
26 _teste_B.HighestOne4 (inseguro) 785.504
27 _teste_B.HighestOne5 (inseguro) 789.797
28 _test_A.HighestOne0 (inseguro) 809.566
29 _test_B.HighestOne0 (inseguro) 814.990
30 _highest_one_bit.HighestOne 824.345
30 _bitarray_ext.RtlFindMostSignificantBit 894.069
31 candidatos. HighestOne_Naive 898.865

Notável é que o péssimo desempenho de ntdll.dll!RtlFindMostSignificantBitvia P / Invoke:

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

É realmente uma pena, porque aqui está toda a função real:

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

Não consigo imaginar o desempenho ruim originado com essas cinco linhas, então as penalidades de transição gerenciada / nativa devem ser as culpadas. Também fiquei surpreso que o teste realmente favoreceu as shorttabelas de pesquisa direta de 32 KB (e 64 KB) (16 bits) em relação às tabelas de pesquisa de 128 bytes (e 256 bytes) byte(8 bits). Achei que o seguinte seria mais competitivo com as pesquisas de 16 bits, mas o último superou consistentemente isso:

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];
}

A última coisa que vou apontar é que fiquei bastante chocado porque meu método deBruijn não se saiu melhor. Este é o método que eu estava usando amplamente anteriormente:

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];
}