Побитовая перестановка нескольких 64-битных значений параллельно / в сочетании

Я думаю, что вы, возможно, ищете бит-нарезки реализации. Это как самый быстрый де-трескать impelmentations работы. (Или это было до того, как существовали инструкции SSE.)

идея состоит в том, чтобы написать свою функцию "битовым" способом, представляя каждый выходной бит как логическое выражение над входными битами. Поскольку каждый выходной бит зависит только от входных битов, любая функция может быть представлена таким образом, даже такие вещи, как сложение, умножение, или поиск S-box.

трюк состоит в том, чтобы использовать фактические биты одного регистра для представления один бит из нескольких входных слов.

я проиллюстрирую простой четырехбитной функцией.

предположим, например, вы хотите взять четырехразрядные входы формы:

x3 x2 x1 x0

...и для каждого входа вычислите четырехбитный выход:

x2 x3 x2^x3 x1^x2

и вы хотите сделать это, скажем, восемь входов. (OK для четырех бит a таблица поиска будет самой быстрой. Но это только для иллюстрации принципа.)

предположим, что ваши восемь входов:

A = a3 a2 a1 a0
B = b3 b2 b1 b0
...
H = h3 h2 h1 h0

здесь a3 a2 a1 a0 представляют четыре бита A input, etc.

во-первых, Закодируйте все восемь входов в четыре байта, где каждый байт содержит один бит от каждого из восьми входов:

X3 =  a3 b3 c3 d3 e3 f3 g3 h3
X2 =  a2 b2 c2 d2 e2 f2 g2 h2
X1 =  a1 b1 c1 d1 e1 f1 g1 h1
X0 =  a0 b0 c0 d0 e0 f0 g0 h0

здесь a3 b3 c3 ... h3 - это восемь битов X3. Он состоит из высоких битов всех восьми входов. X2 - это следующий бит из всех восьми входов. И так далее.

теперь, чтобы вычислить функцию восемь раз параллельно, вы просто делаете:

Y3 = X2;
Y2 = X3;
Y1 = X2 ^ X3;
Y0 = X1 ^ X2;

теперь Y3 держит высокие биты от всех восьми выходов, Y2 держит следующий бит от всех восьми выходов и так далее. Мы только что вычислили эту функцию на восьми разных входах, используя только четыре машинные инструкции!

еще лучше, если наш процессор 32-разрядный (или 64-разрядный), мы могли бы вычислить эту функцию на 32 (или 64) входах, все еще используя только четыре инструкции.

кодирование ввода и декодирование вывода в / из представления "битовый срез" занимает некоторое время, конечно. Но для правильной функции этот подход предлагает массовый параллелизм на уровне битов и, следовательно, массовое ускорение.

основное предположение заключается в том, что у вас есть много входов (например, 32 или 64), на которых вы хотите вычислить ту же функцию, и что функция не слишком сложна и не слишком проста для представления в виде группы булевых операций. (Слишком жесткий делает необработанное вычисление медленным; слишком простой делает время, доминирующее над самим кодированием/декодированием битового среза.) Для криптографии, в частности, где (а) данные должны пройти через много "раундов" обработки, (б) алгоритм часто с точки зрения бит уже мунгинга, и (в) вы, например, пробуете много ключей на одних и тех же данных... Это часто работает довольно хорошо.

кажется трудным выполнить перестановку только в одном вызове. Частный случай вашей проблемы, обращая биты в целое число, требует более одного "вызова" (что вы подразумеваете под вызов?). См.бит Twiddling хаки Шон по информации этого примера.

Если ваш шаблон отображения не сложен, возможно, вы можете найти быстрый способ вычислить ответ:) однако я не знаю, нравится ли вам этот прямой способ:

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

лучше всего было бы посмотреть на какой-то тип схемы резьбы ... либо вы можете использовать систему передачи сообщений, где вы отправляете каждый блок фиксированному набору рабочих потоков, либо вы можете настроить конвейер с неблокирующимися одиночными очередями производителя/потребителя, которые выполняют несколько сдвигов "синхронно". Я говорю "синхронный", потому что конвейер на ЦП общего назначения не был бы действительно синхронной операцией конвейера, как на устройстве с фиксированной функцией, но в основном для данного " среза "времени каждый поток будет работать на одном этапе многоступенчатой проблемы одновременно, и вы будете" передавать " исходные данные в конвейер и из него.