Efficient bit shuffling between multiple words - c

Question

Say I have 8 32-bit registers:
A 0-31 E 0-31
B 0-31 F 0-31
C 0-31 G 0-31
D 0-31 H 0-31
And I want their bits rearranged like:
A' := A0 E0 A8 E8 A16 E16 A24 E24 B0 F0 B8 F8 B16 F16 B24 F24 C0 G0 ...etc. H24
B' := A1 E1 A9 E9 A17 E17 A25 E25 B1 F1 B9 F9 B17 F17 B25 F25 C1 G1 ...etc. H25
C' := A2 E2 A10 E10 A18 E18 A26 E26 B2 ... etc.
D' := ... etc.
E' := ... etc.
F' := ... etc.
G' := ... etc.
H' := ... etc.
What would be the most efficient way to compute this shuffling in either C or ARM assembly? (So no intel with SSE, no 64-bit registers, not enough registers to contain both input and output.) The calculator at http://programming.sirrida.de/calcperm.php is really nice, but it doesn't easily extend to multiple words. I believe it can be done more efficiently than the naive way of selecting one bit at the time.

Answer 1

If you make components A0 _ _ _ _ _ _ _ A8 _ _ _ _ _ _ _ A16 etc (just trivial masking).
And similar for the other registers, you can easily make this:
A0 E0 B0 F0 C0 G0 D0 H0 A8 E8 ..
Which you can turn into the right order with two bit_permute_step's, as given by calcperm:
x = bit_permute_step(x, 0x00cc00cc, 6); // Bit index swap 1,3
x = bit_permute_step(x, 0x0000f0f0, 12); // Bit index swap 2,4
Similar story for the other registers, just offset a bit.
Essentially moving 4 bits at once, with a bit of fixup which only happens 8 times.

Answer 2

; 1) Copy the top most 8 bits of H into the lowest bits of the output registers:
lsr H ; H.31 -> carry
rol H' ; carry -> H'.0
lsr H ; H.30 -> carry
rol G' ; carry -> G'.0
lsr H
rol F'
...
lsr H ; H.24 -> carry
rol A' ; carry to A'.0
; 2) go on with top 8 bits of D
lsr D ; D.31 -> carry
rol H' ; H'.0 -> H'.1 and carry -> H'.0
lsr D
rol G'
...
lsr D
rol A'
Continue until all bits are in place. The last step is
lsr A ; A.0 -> carry
rol A' ; A'.0 -> A'.1 -> A'.2 ... and carry -> A'.0

Answer 3

the fastest version I came up with:
// merges 32 bit a (low) and b (hi) into single 64 bit
#define m(a, b) (((uint64_t) (a)) | (((uint64_t) (b)) << 32))
// gets bit at position opos and moves it to position npos
#define s(a, opos, npos) (((opos) >= (npos)) ? (((a) & ( ((uint64_t)1) << (opos))) >> ((opos) - (npos))) : (((a) & (((uint64_t)1) << (opos))) << ((npos) - (opos))))
// gets 8 different bits from 64 bit number and puts them together into 1 byte, starting from idx
#define b(a, idx) (s(a, 0, idx) | s(a, 32, (idx - 1)) | s(a, 8, (idx - 2)) | s(a, 40, (idx - 3)) | s(a, 16, (idx - 4)) | s(a, 48, (idx - 5)) | s(a, 24, (idx - 6)) | s(a, 56, (idx - 7)))
// takes 8 32 bit registers in in, outputs in out
void shuffle(const uint32_t* in, uint32_t* out) {
uint64_t t[4] = { m(in[0], in[4]), m(in[1], in[5]), m(in[2], in[6]), m(in[3], in[7]) };
for (int i = 0; i < 8; i++, t[0] >>= 1, t[1] >>= 1, t[2] >>= 1, t[3] >>= 1)
out[i] = b(t[0], 31) | b(t[1], 23) | b(t[2], 15) | b(t[3], 7);
}
the only "optimization" in comparison to straight forward approach is to merge two 32 bit registers into single 64 bit, so we can reduce number of shifts in loop

Answer 4

On x86 with SSE: punpcklbw (_mm_unpacklo_epi8 can interleave bytes of the source regs.
Use vector shifts then pmovmskb to grab the high bit of each byte, giving you results like
A0 E0 A8 E8 A16 E16 A24 E24
Then combine these byte results to get the 8 dest registers. This kind of sucks, because it requires a shift/pmovmskb for each of result byte. There are 8 * 4 result bytes, so that's a lot of code.

Answer 5

I'm a bit late to the party but I'll post an answer anyway.
Firstly, notice that the bytes in the output words each use only even/odd bits of a pair of input words. combining the odd bits of A with the even bits of B gives all the bits necessary for the first byte of A,C,E,G. Code for the resulting permutation can be found via the calculator linked above and simplifies to two bit swapping operations per word. The resulting bytes can be written back to memory in their correct locations and read back if necessary.
Permuting the bytes within a word costs about as much as writing out the bytes to memory but is also possible.
Cost is 17 bit operations per word. A little less on ARM where rotations are free. Vectorisation is easy with byte shuffling replacing the last step.
The following vanilla C code should do it:
#include <stdio.h>
#include <stdint.h>
int32_t inline bit_permute_step(int32_t x, int32_t m, int shift) {
int32_t t;
t = ((x >> shift) ^ x) & m;
x = (x ^ t) ^ (t << shift);
return x;
}
void permute(int32_t input[8], int32_t output[8]){
int8_t *outputc=(int8_t*)output;
for(int i=0;i<4;i++){
int32_t A=input[3-i];
int32_t E=input[3-i+4];
//swap the even bits of A/B/C/D with the odd bits of E/F/G/H
int32_t t=(A^(E>>1))&0x55555555;
A^=t;E^=t<<1;
A = bit_permute_step(A, 0x00cc00cc, 6); // Bit index swap 1,3
E = bit_permute_step(E, 0x00cc00cc, 6); // Bit index swap 1,3
A = bit_permute_step(A, 0x0000f0f0, 12); // Bit index swap 2,4
E = bit_permute_step(E, 0x0000f0f0, 12); // Bit index swap 2,4
outputc[i+0 ]=A>>24;
outputc[i+4 ]=E>>24;
outputc[i+8 ]=A>>16;
outputc[i+12]=E>>16;
outputc[i+16]=A>>8;
outputc[i+20]=E>>8;
outputc[i+24]=A;
outputc[i+28]=E;
}
}
void printBits(unsigned int num){
for(int bit=31;bit>=0; bit--){
printf("%i", (num>>bit)&1);
if(bit && !(bit&7)){printf(" ");}
}printf("\n");
}
int32_t main(){
volatile int32_t input[8]=
{0xf<<0,0xf<<8,0xf<<16,0xf<<24,0xf<<4,0xf<<12,0xf<<20,0xf<<28};
int32_t output[8]={-1,-1,-1,-1,-1,-1,-1,-1};
printf("input\n");
permute((int32_t*)input,output);
for(int i=0;i<8;i++){
printf(" %c:",'A'+i);
printBits(input[i]);
}
printf("output\n");
for(int i=0;i<8;i++){
printf(" %c:",'A'+i);
printBits(output[i]);
}
}