setrounding regression for 0.5.0-rc1

[omus]

Taken from a rounding mode example in the manual:

Julia 0.4.6

julia> with_rounding(Float64,RoundDown) do
           1.1 + 0.1
       end
1.2

julia> 1.1 + 0.1
1.2000000000000002

Julia 0.5.0-rc1

julia> setrounding(Float64,RoundDown) do
           1.1 + 0.1
       end
1.2000000000000002

julia> 1.1 + 0.1
1.2000000000000002

[omus]

Looks to be that the example function is being optimized:

julia> x = 0.1
0.1

julia> setrounding(Float64,RoundDown) do
           1.1 + x
       end
1.2

[Keno]

I suspect this is LLVM inlining and constant folding. LLVM doesn't model rounding modes, so there is very little we can do.

[omus]

Makes sense. I guess the best course of action would be to update the manual to have a more complicated but working example.

[simonbyrne]

That's not good: previously we relied on the fact that anonymous functions weren't really optimised. Now that they are, I'm not sure what we can do until LLVM get around to allowing rounding mode changes (I wouldn't hold your breath...).

We should probably stick some warnings in there, and mark it as an experimental feature.

[yuyichao]

IIUC constant folding are usually done at default rounding mode. I don't think it's possible to know the right rounding mode anyway unless we disable all constant folding for floating point numbers since the rounding mode is a runtime setting.

[simonbyrne]

Could we have a meta tag that would disable constant folding in a particular region?

[yuyichao]

@noinline

[simonbyrne]

Doesn't that just disable constant folding at definition time? How could I use it in the above example?

[yuyichao]

@noinline f() = 1.0; f() + 1.1

[yuyichao]

I just mean that @noinline is the only reliable optimization barrier we have and is likely to stay for some time.

[simonbyrne]

So one option is that we could change it to a macro which pulls out all the literals into a @noinline call, i.e.

@setrounding Float64 RoundDown 1.1 + 0.1

transforms to

@noinline literals() = (1.1,0.1)
old = rounding(Float64)
setrounding(Float64, RoundDown)
a,b = literals()
a+b
setrounding(Float64, old)

[simonbyrne]

Although that won't work with consts...

[dpsanders]

Ouch. This sounds like it will seriously break ValidatedNumerics.jl.
Why did this not get picked up by the Julia test suite?

[KristofferC]

How did it not get picked up by your test suite? :P

[dpsanders]

Apparently because we never have literals; everything that gets rounded comes out of an Interval object.

[tkelman]

I guess our rounding-mode tests aren't as comprehensive as they could be? That doc example was also not a doctest, but if it had been we likely would have noticed sooner.

[simonbyrne]

setrounding has now been deprecated: #27166