This post contains the same material as this thread of tweets, with a few minor edits.
In IEEE754, floating point numbers are represented like this:
nnn is the exponent, which is floor(log2(size)) — which happens to be the fl value computed by TLSF.
sss… is the significand fraction: the part that follows the decimal point, which happens to be sl.
And so to calculate fl and sl, all we need to do is convert size to a floating point value (on recent x86 hardware, that’s a single instruction). Then we can extract the exponent, and the upper bits of the fractional part, and we’re all done :D
That can be implemented like this:
double sf = (int64_t)size; uint64_t sfi; memcpy(&sfi, &sf, 8); fl = (sfi >> 52) - (1023 + 7); sl = (sfi >> 47) & 31;
There’s some subtleties (there always is). I’ll break it down…
double sf = (int64_t)size;
Convert size to a double, with an explicit cast. size has type size_t, but using TLSF from github.com/mattconte/tlsf, the largest supported allocation on 64bit architecture is 2^32 bytes – comfortably less than the precision provided by the double type. If you need your TLSF allocator to allocate chunks bigger than 2^53, this isn’t the technique for you :)
I first tried using float (not double), which can provide correct results — but only if the rounding mode happens to be set correctly. double is easier.
The cast to (int64_t) results in better codegen on x86: without it, the compiler will generate a full 64bit unsigned conversion, and there is no single instruction for that.
The cast tells the compiler to (in effect) consider the bits of size as if they were a two’s complement signed value — and there is an SSE instruction to handle that case (cvtsi2sdq or similar). Again, with the implementation we’re using size can’t be that big, so this will do the Right Thing.
uint64_t sfi; memcpy(&sfi, &sf, 8);
Copy the 8 bytes of the double into an unsigned integer variable. There are a lot of ways that C/C++ programmers copy bits from floating point to integer – some of them are well defined :) memcpy() does what we want, and any moderately respectable compiler knows how to select decent instructions to implement it.
Now we have floating point bits in an integer register, consisting of one sign bit (always zero for this, because size is always positive), eleven exponent bits (offset by 1023), and 52 bits of significant fraction. All we need to do is extract those, and we’re done :)
fl = (sfi >> 52) - (1023 + 7);
Extract the exponent: shift it down (ignoring the always-zero sign bit), subtract the offset (1023), and that 7 we saw earlier, at the same time.
sl = (sfi >> 47) & 31;
Extract the five most significant bits of the fraction – we do need to mask out the exponent.
And, just like that*, we have mapping_insert(), implemented in terms of integer -> floating point conversion.
* Actual code (rather than fragments) may be included in a later post…