Fastest way to unpack bits into single precision floats - c++

Question

This is platform specific question. Speed is crucial.
What is the fastest way to unpack a byte into an array of 8 single precision floats so that zeroes map into zeroes and ones map into ones?
I ended up using 8 bit masks and 7 bit shifts to unpack into 8 int32's and then an AVX instruction to convert int32's into floats.
My platform is Windows 64 bit running on AVX (but no AVX2) capable CPU. Compiler: Visual Studio 2013.
Thanks.

Answer 1

Wouldn't preprocessing be faster? 2^8 possibilities is pretty much, but then again, just split it into two parts, and it's only 2^4 = 16 variables.
Make array consiting of 16 "values", where each value is array filled with 4 floats with right values. Then your cost would be only 2 * (copy data from preprocessed array to new array).
I'm not too deep into assembly, but two copy's should be faster then some loops etc.
unsigned char myByte; // input byte (pattern to create floats)
float preprocessingArrays[16][4] = {
{ 0.0f, 0.0f, 0.0f, 0.0f }, // 0000
// ...
{ 1.0f, 1.0f, 1.0f, 1.0f } // 1111
};
float result[8];
std::memcpy(&result[0], &preprocessingArrays[myByte >> 4][0], 16);
std::memcpy(&result[4], &preprocessingArrays[myByte & 15][0], 16);
// 16 = platform-specific -> floats should be 32bits -> 4bytes * 4 floats = 16
This is written from hand, but as you can see mine loop would consists of two memcpys, one bitshift and one binary AND operation (or only one, but bigger, memcpy, if you want to make preprocessing for 2^8 values).
For C(++) only code i think this would beat loops etc. but assembler code might be faster, i'm not that sure. Maybe you could perform memcpy operation using assembler and in one go read whole 4 floats and then write it in another one call. AVX seems to support up to 16 256bits registers, so it might be possible to just calculate from which register (of 16 possible values) copy value where and this would be very fast.
Also not to write so much code yourself, just make simple program which would print preprocessing values for you, copy it and paste into original program :)

Answer 2

Loops, conditions and going through an actual array in memory are of course not the vector way. So here's an other idea, though it's a bit annoying in only AVX. Since without AVX2 you can do almost nothing with an ymm register (nothing useful anyway), just use two xmm registers and then in the end vinsertf128 the high part to form the whole thing. Mixing like this is OK as long as the operations on xmm registers use VEX encoded instructions (so 'v' goes in front of everything, even when it may seem unnecessary).
Anyway, the idea is to put a copy of the byte in every dword, AND with the right bit per lane and compare to form masks. In the end we can do a single bitwise AND to turn the masks into 0f or 1f.
So, first get that byte everywhere, let's say it's in eax, doesn't really matter:
vmovd xmm0, eax
vpshufd xmm0, xmm0, 0
Extract the right bits:
vpand xmm0, xmm0, [low_mask]
vpand xmm1, xmm0, [high_mask]
The masks are 1, 2, 4, 8 and 16, 32, 64, 128 (this is in memory order, if you use _mm_set_epi32 they have to be the other way around)
Compare to form the masks:
vpxor xmm2, xmm2, xmm2
vpcmpgtd xmm0, xmm0, xmm2
vpcmpgtd xmm1, xmm1, xmm2
Merge:
vinsertf128 ymm0, ymm0, xmm1, 1
Turn into 0f or 1f:
vandps ymm0, ymm0, [ones]
ones is just 1f duplicated 8 times.
I don't know if this is faster, but it's worth a try. Also, none of this was tested.
I tried to convert it to intrinsics, but I have no idea what I'm doing (and it's not tested). Also, be careful that it compiles with VEX prefixes, or it'll cause expensive mode-switching.
// broadcast
__m128i low = _mm_set1_epi32(mask);
__m128i high = _mm_set1_epi32(mask);
// extract bits
low = _mm_and_si128(low, _mm_set_epi32(8, 4, 2, 1));
high = _mm_and_si128(high, _mm_set_epi32(128, 64, 32, 16));
// form masks
low = _mm_cmpgt_epi32(low, _mm_setzero_si128());
high = _mm_cmpgt_epi32(high, _mm_setzero_si128());
// stupid no-op casts
__m256 low2 = _mm256_castps128_ps256(_mm_castsi128_ps(low));
__m128 high2 = _mm_castsi128_ps(high);
// merge
__m256 total = _mm256_insertf128_ps(low2, high2, 1);
// convert to 0f or 1f
total = _mm256_and_ps(total, _mm256_set1_ps(1.0f));
With GCC at least, that generates OK code. It uses vbroadcastss for the set1 (instead of the vpshufd's that I used), I'm not sure how good that idea is (it means it has to bounce that int through memory).
With AVX2 it can be much simpler:
__m256i x = _mm256_set1_epi32(mask);
x = _mm256_and_si256(x, _mm256_set_epi32(128, 64, 32, 16, 8, 4, 2, 1));
x = _mm256_cmpgt_epi32(x, _mm256_setzero_si256());
x = _mm256_and_si256(x, _mm256_set1_epi32(0x3F800000));
return _mm256_castsi256_ps(x);

Answer 3

void byteToFloat(const uint8_t byteIn,
float *const restrict floatOut)
{
floatOut[0]=(byteIn&0x01)?1.0f:0.0f;
floatOut[1]=(byteIn&0x02)?1.0f:0.0f;
floatOut[2]=(byteIn&0x04)?1.0f:0.0f;
floatOut[3]=(byteIn&0x08)?1.0f:0.0f;
floatOut[4]=(byteIn&0x10)?1.0f:0.0f;
floatOut[5]=(byteIn&0x20)?1.0f:0.0f;
floatOut[6]=(byteIn&0x40)?1.0f:0.0f;
floatOut[7]=(byteIn&0x80)?1.0f:0.0f;
}
In x86-64 architectures from both Intel and AMD, branch predication
may be performed through the use of conditional move operations
(cmove): a source operand is conditionally moved to the destination
operand depending on the value of a flag register.
http://en.wikipedia.org/wiki/Branch_predication

Answer 4

Indexing, as #RippeR suggests, is my first guess too.
My second guess is something like this:
switch(theChar){
break; case 0: result[0] = 0; ... result[7] = 0;
break; case 1: result[0] = 0; ... result[7] = 1;
...
break; case 255: result[0] = 1; ... result[7] = 1;
}
It's wordy code, but you could get the preprocessor to help you write it.
The reason this might be faster is the switch should turn into a jump table, and the moves should optimize pretty well.
ADDED: if you're wondering how the preprocessor could help, here's something:
#define FOO(x,i) result[i] = !!((x) & (1<<(i)))
#define BAR(x) break; case x: FOO(x,0);FOO(x,1); ... FOO(x,7)
switch(theChar){
BAR(0);
BAR(1);
...
BAR(255);
}