How can I convert from float (1bit sign, 8bit exp, 23bit mantissa) to Bfloat16 (1bit sign, 8bit exp, 7bit mantissa) in C++?
3
3 Answers
As demonstrated in the answer by Botje it is sufficient to copy the upper half of the float value since the bit patterns are the same. The way it is done in that answer violates the rules about strict aliasing in C++. The way around that is to use memcpy to copy the bits.
static inline tensorflow::bfloat16 FloatToBFloat16(float float_val)
{
tensorflow::bfloat16 retval;
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
memcpy(&retval, &float_val, sizeof retval);
#else
memcpy(&retval, reinterpret_cast<char *>(&float_val) + sizeof float_val - sizeof retval, sizeof retval);
#endif
return retval;
}
If it's necessary to round the result rather than truncating it, you can multiply by a magic value to push some of those lower bits into the upper bits.
float_val *= 1.001957f;
3 Comments
ChipK
This is sufficient but does NOT take into account correct rounding.
Mark Ransom
@ChipK I include a way to do rounding if necessary, in what way is it not correct?
ChipK
You are correct. I missed that part about multiplying by a magic number.
memcpy wouldn't compile for me in the little endian case for some reason. This is my solution. I have it as a struct here so that I can easily access the data and run through different ranges of values to confirm that it works properly.
struct bfloat16{
unsigned short int data;
public:
bfloat16(){
data = 0;
}
//cast to float
operator float(){
unsigned int proc = data<<16;
return *reinterpret_cast<float*>(&proc);
}
//cast to bfloat16
bfloat16& operator =(float float_val){
data = (*reinterpret_cast<unsigned int *>(&float_val))>>16;
return *this;
}
};
//an example that enumerates all the possible values between 1.0f and 300.0f
using namespace std;
int main(){
bfloat16 x;
for(x = 1.0f; x < 300.0f; x.data++){
cout<<x.data<<" "<<x<<endl;
}
return 0;
}
3 Comments
wolfram77
Works great :). Do check this answer, which also include
operator >> overload for cin: stackoverflow.com/a/56017304/1413259
phuclv
using
reinterpret_cast for type punning invokes undefined behavior?. You need to use bit_cast instead: Why was std::bit_cast added, if reinterpret_cast could do the same?
Dwayne Robinson
Converting float32 to bfloat16 via
>> can lose NaN's when the lower bits are shifted out (NaN is represented as a maximal exponent and any nonzero bits in the fraction/mantissa part, meaning anything greater than infinity). To preserve NaN's, try ... = (float32AsUint >> 16) | ((float32AsUint & 0x7FFFFFFF) > 0x7F800000) ? 1 : 0);.From the Tensorflow implementation:
static inline tensorflow::bfloat16 FloatToBFloat16(float float_val) {
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
return *reinterpret_cast<tensorflow::bfloat16*>(
reinterpret_cast<uint16_t*>(&float_val));
#else
return *reinterpret_cast<tensorflow::bfloat16*>(
&(reinterpret_cast<uint16_t*>(&float_val)[1]));
#endif
}
8 Comments
Alexey Frunze
I think that implementation is flawed because it violates aliasing. If you copy the two bytes as individual bytes (e.g.
unsigned char's), it'll be right.
user179156
@AlexeyFrunze : why is de-referencing violating aliasing ? It seems like it should be fine since we never update/modify or write to
float_val , if we are just reading and never writing to the different pointer type , is it still a violation or UB ?Alexey Frunze
@user179156 Doesn't matter. You can legally peek/poke an object through a pointer to a compatible type, a pointer to the (un)signed variant of the same type, or a pointer to a char. float and uint16_t is not an allowed pair here (unless uint16_t is a type name that stands for unsigned char).
user179156
@AlexeyFrunze : got it . thanks . Could you please give an example why such a rule was decided. Understand that this is what standard says but do not understand the rationale and what can possibly go wrong , any code snippet or example would help
Alexey Frunze
@user179156 For one, different types may have different alignments and using a badly aligned pointer may not work how one may expect it to (it may not work at all, just crash your program). For another, this rule gives the compiler the ability to know that certain pointers in the code never point to the same object and the compiler can safely make optimizations (like caching the object in a register, knowing it won't mysteriously change through some other pointer).
|
frexpcan be used to break afloatdown into components. Assembling it back into whatever structure you callBfloat16is left as an exercise for the reader.