Make Float16(::BigFloat) go through Float64

[oscardssmith]

Doesn't fix double rounding issues, but makes them occur 2^29 times less frequently. Should have minimal performance effects.

[oscardssmith]

Can we get a review and merge on this? It's very low impact and a strict improvement.

[oscardssmith]

Bump on this.

[oscardssmith]

Thanks!

[kimikage]

xref: https://discourse.julialang.org/t/os-dependency-of-float16-bigfloat-on-nightly/58414

[oscardssmith]

I think the best solution to this is probably to write our own version of Float16(::Float64) so that the OS can't get it wrong.

[oscardssmith]

I think the following is a correct implementation. It is 3x slower for Float32 (not fully sure why), but is about 13% faster for Float64.

function gentables()
	BASE  = zeros(UInt16, 512)
	SHIFT = zeros(UInt8,  512)
	for i in 1:256
	    e=i-128
	    if e<-24
			BASE[i|0x000]=0x0000
			BASE[i|0x100]=0x8000
			SHIFT[i|0x000]=24
			SHIFT[i|0x100]=24;
		elseif e<-14
			BASE[i|0x000]=(0x0400>>(-e-14))
			BASE[i|0x100]=(0x0400>>(-e-14)) | 0x8000
			SHIFT[i|0x000]=-e-1
			SHIFT[i|0x100]=-e-1
		elseif e<=15
			BASE[i|0x000]=((e+15)<<10)
			BASE[i|0x100]=((e+15)<<10) | 0x8000
			SHIFT[i|0x000]=13
			SHIFT[i|0x100]=13
		elseif(e<128)
			BASE[i|0x000]=0x7C00
			BASE[i|0x100]=0xFC00
			SHIFT[i|0x000]=24
			SHIFT[i|0x100]=24
		else
			BASE[i|0x000]=0x7C00
			BASE[i|0x100]=0xFC00
			SHIFT[i|0x000]=13
			SHIFT[i|0x100]=13
		end
	end
	return Tuple(BASE), Tuple(SHIFT)
end
const BASE, const SHIFT = gentables()

function Float16(x::Float32)
	xu = reinterpret(UInt32, x)
	e = (xu>>23)&0x1ff+1
	ans  = @inbounds BASE[e]
	ans += unsafe_trunc(Int16, ((xu&0x7fffff)>>SHIFT[e]))
	return reinterpret(Float16, ans)
end

function Float16(x::Float64)
	xu = reinterpret(UInt64, x)
	e = xu>>52
	e = ifelse(e<2048, clamp(e-895,  1,   256), 
					   clamp(e-2687, 257, 512))
	ans  = @inbounds BASE[e]
	ans += @inbounds unsafe_trunc(Int16, ((xu&0xfffffffffffff)>>(SHIFT[e]+29)))
	return reinterpret(Float16, ans)
end

[kimikage]

The Ivy Bridge and newer x86 processors have Float32 <--> Float16 conversion instructions. That's earlier than the advent of AVX2. Although I am not familiar with Arm, we can practically assume that most processors support them.

See also #37510