Permutation binaire de plusieurs valeurs 64 bits en parallèle / combinée

Il semble difficile de faire la permutation dans un seul appel. Un cas particulier de votre problème, des bits d'inverser dans un entier, a besoin de plus d'un "appel" (qu'entendez-vous par appelez em>?). Voir Bit Twiddling Hacks de Sean pour des informations sur cet exemple.

Si Votre modèle de mappage n'est pas compliqué, vous pouvez peut-être trouver un moyen rapide de calculer la réponse :) Cependant, je ne sais pas si vous aimez cette méthode directe: p>

#include <stdio.h>

unsigned char mask[8];

//map bit to position
//0 -> 2
//1 -> 7
//2 -> 5
//...
//7 -> 6
unsigned char map[8] = {
    2,7,5,1,4,0,3,6
};


int main()
{
    int i;

    //input:
    //--------------------
    //bit 7 6 5 4 3 2 1 0
    //--------------------
    //val 0 0 1 0 0 1 1 0
    //--------------------
    unsigned char input = 0x26;

    //so the output should be 0xA1:
    //    1 0 1 0 0 0 0 1
    unsigned char output;

    for(i=0; i<8; i++){ //initialize mask once
        mask[i] = 1<<i;
    }

    //do permutation
    output = 0;
    for(i=0; i<8; i++){
        output |= (input&mask[i])?mask[map[i]]:0;
    }

    printf("output=%x\n", output);
    return 0;
}

Votre meilleur pari serait de regarder dans un type de schéma de filetage ... Vous pouvez utiliser un système de passage de message où vous envoyez chaque bloc à un ensemble fixe de threads ouvriers ou vous pouvez éventuellement configurer un pipeline avec non. -Locking unique producteur / file d'attente de consommateurs qui effectuent plusieurs quarts de travail de manière "synchrone". Je dis "synchrone" car un pipeline sur une CPU à usage général ne serait pas une opération de pipeline véritablement synchrone, comme si vous auriez sur un dispositif de fonction fixe, mais essentiellement pour une "tranche" donnée, chaque fil fonctionnerait sur Une étape du problème multi-étapes en même temps et vous «diffuseriez» les données source dans et hors du pipeline.

Vous pouvez rendre le code bit-bit de Stan plus rapidement en utilisant huit tables de recherche cartographier des octets à 64 bits. Pour traiter un mot de 64 bits à partir de l'entrée, divisez-le en huit octets et recherchez chacun d'une table d'apparence différente, puis des résultats. Sur mon ordinateur, ce dernier est 10 fois plus rapide que l'approche bit-bit pour des permutations 32 bits. Évidemment, si votre système embarqué a peu de cache, alors 32 Ko 16 Ko de tables de recherche peut être un problème. Si vous traitez 4 bits à la fois, vous n'avez besoin que de 16 tables de recherche de 16 * 8 = 128 octets chacun, c'est-à-dire 2 Ko de tables de recherche.

Edit: La boucle interne pourrait ressembler à ceci: < / p> xxx