miroir bits d'un mot de 32 bits

Je pense que je ferais une table de recherche de Bitpatterns 0-255. Lisez chaque octet et avec la table de recherche inverse que l'octet et ensuite arrangez les octets résultants de manière appropriée.

L'approche la plus rapide est presque sûre d'être une table de recherche: xxx pré>

ou si vous pouvez vous permettre de fournir 128k de données de table (en vous permettant, je veux dire l'utilisation du cache de la CPU, pas la mémoire principale ou la mémoire virtuelle UTILISATION), Utilisez des unités 16 bits: P>

out[0]=lut[in[1]];
out[1]=lut[in[0]];

quint64 mirror(quint64 a,quint8 l=64) {
    quint64 b=0;
    for(quint8 i=0;i<l;i++) {
        b|=(a>>(l-i-1))&((quint64)1<<i);
    }
return b;
}
This function mirroring less then 64 bits. For instance it can mirroring 12 bits.quint64 and quint8 are defined in Qt. But it possible redefine it in anyway.

J'ai également juste compris une solution minimale pour mettre en miroir 4 bits (un grignotant) dans un espace temporaire de 16 bits.

mirr = ( (orig * 0x222) & 0x1284 ) % 63

int mirror (int input)
{// return bit mirror of 8 digit number 
  int tmp2;
  int out=0;
  for (int i=0; i<8; i++)
    {
      out = out << 1;
      tmp2 = input & 0x01;
      out = out | tmp2;
      input = input >> 1;        
    }
   return out;
}

presque un duplicata de algorithme le plus efficace pour l'inversion de bits (de MSB-> LSB au LSB-> MSB) en C (qui a beaucoup de réponses, y compris une réponse AVX2 pour l'inverser tous les 8 bits de charratage) .

x86

sur x86 avec SSSE3 (core2 et plus tard, bulldozer et plus tard), pshufb ( _mm_shauffle_epi8 ) peut être utilisé comme nibble lut pour faire 16 recherches en parallèle. Vous n'avez besoin que de 8 recherches pour les 8 grignotants dans un entier unique 32 bits, mais le problème réel divise les octets d'entrée en grignotins séparés (avec leur moitié supérieure à zéro zéro). C'est fondamentalement le même problème que pour PSHUFB POPCOUNT BASED.

Les bits d'enregistrement AVX2 inverser montre comment faire cela pour un vecteur emballé d'éléments 32 bits. Le même code porté sur des vecteurs de 128 bits compilerait simplement avec AVX.

Il est toujours bon pour un seul Int 32 bits car x86 a une excursion ronde très efficace entre INTEGER et Vector Regs: int Bitrev = _mm_cvtsi128_si32 (RBA32 (_mm_cvtsi32_si128 (entrée))); . Cela coûte seulement 2 instructions supplémentaires movd pour obtenir un entier d'un registre entier dans XMM et en arrière. (Latence ronde = 3 cycles sur un processeur Intel comme Haswell.)

---

bras:

rbit a une latence à cycle unique et fait un entier entièrement 32 bits dans une instruction.