Minha tarefa é verificar (> trilhões de verificações), dois int contêm qualquer par predefinido de petiscos (primeiro par 0x2 0x7; segundo 0xd 0x8). Por exemplo:

bit offset:   12345678
first int:  0x3d542783     first pair of  0x2    second:   0xd   
second int: 0x486378d9      nibbles:      0x7      pair:   0x8
               ^  ^

Portanto, neste exemplo, marquei duas compensações com os pares necessários (as compensações são 2 e 5; mas não um 7). Compensações reais e número de pares encontrados não são necessários na minha tarefa.

Portanto, para duas entradas dadas, a questão é:Eles contêm qualquer um desses pares de petiscos no mesmo deslocamento.

Eu verifiquei meu programa, essa parte é o lugar mais quente (gprof comprovada); e é chamado de muito, muito, muitas vezes (gcov comprovada). Na verdade, é o terceiro ou o quarto loop (mais aninhado) dos loops aninhados.

Meu código atual é lento (eu o reescrevo como função, mas é um código do loop interno):

static inline int nibble_check (uint32_t A, uint32_t B)
 __attribute__((always_inline))
{
  int i;
  for(i=0;i<8;i++)

    if(  ( ( (A&0xf) ==0xD) && ( (B&0xf) ==0x8) )     // first pair
      || ( ( (A&0xf) ==0x2) && ( (B&0xf) ==0x7) )  )  // second pair
        return 1; // nibbles found
    else {
        A>>=4;
        B>>=4;
    }

  return 0; // nibbles not found
}

A outra tarefa é encontrar esses pares não apenas nas compensações de 0,4,8 bits e assim por diante, mas nas compensações de 0,2,4,8,10, ... bits:

#define douburu_nibble_check(A,B) (nibble_check(A,B) || nibble_check(A>>2, B>>2) )

É possível reescrever essa função e macro de maneira paralela?

Meu compilador é o gcc452 e a CPU é o Intel Core2 Solo no modo de 32 bits (x86).