"nested if" versus "if and" performance using F#

Question

The following code results in slow1 = 1323 ms, slow2 = 1311 ms and fast = 897 ms. How is that possible?

Here: Nested or not nested if-blocks? they mention that

Any modern compiler, and by that I mean anything built in the past 20 years, will compile these to the same code.

let s = System.Diagnostics.Stopwatch()
let mutable a = 1
s.Start()

for i in 0 .. 1000000000 do
  if i < 0 then
    if i < 0 then
      a <- 4

printfn "fast = %d" s.ElapsedMilliseconds

s.Restart()

for i in 0 .. 1000000000 do
  if i < 0 && i < 0 then
    a <- 4

printfn "slow1 = %d" s.ElapsedMilliseconds

s.Restart()

for i in 0 .. 1000000000 do
  if i < 0 & i < 0 then
    a <- 4

printfn "slow2 = %d" s.ElapsedMilliseconds

Yes. Also Any CPU, X86 and X64. In debug mode both version become equally slow (3083 ms). — Oldrich Svec, Apr 16 '13 at 12:45
I must say that the equally slow result makes much more "sense" then the different ones... — AK_, Apr 16 '13 at 13:05
That is likely due to the short-circuit operator, add timing for `if i < 1000 & i < 1000 then` — leppie, Apr 16 '13 at 13:37
Quick question - if you swap the order of slow and fast does the speed change? — John Palmer, Apr 17 '13 at 01:39

Phil H · Accepted Answer · 2013-04-16T15:30:45.427

I've got hold of the MSIL from ildasm, which I'll post here for someone to elaborate on (no time) - it's community wiki time:

Fast (just the i comparison lines as the rest are identical):

//000030:   if i < 1000 then
  IL_001f:  ldloc.0
  IL_0020:  ldc.i4     0x3e8
  IL_0025:  bge.s      IL_003b
//000031:     if i < 1000 then
  IL_0027:  ldloc.0
  IL_0028:  ldc.i4     0x3e8
  IL_002d:  bge.s      IL_0038

Slow:

//000039:   if i < 1000 && i < 1000 then
  IL_0084:  ldloc.0
  IL_0085:  ldc.i4     0x3e8
  IL_008a:  bge.s      IL_0097
  IL_008c:  ldloc.0
  IL_008d:  ldc.i4     0x3e8
  IL_0092:  clt
  IL_0094:  nop
  IL_0095:  br.s       IL_0099
  IL_0097:  ldc.i4.0
  IL_0098:  nop
  IL_0099:  brfalse.s  IL_00a4

On a side note, C# version of the same has the same timing for both versions.

One thing I noticed in the disassembly was that the F# variables were Program.i and Program.a, so I'm not sure if there's some object interference in F# that isn't there in C#.

That is the output of a Release build with optimisation switched on (VS2012). There is no detail about optimisations, just on or off. — Phil H, Apr 17 '13 at 10:18

score 4 · Answer 2 · answered Apr 17 '13 at 09:25

4

Email from Don Syme:

Yes, we've noticed the thread and recorded an issue. It’s not exactly a bug (the code executes correctly), but it would definitely be good to get equivalent perf here.

answered Apr 17 '13 at 09:25

Oldrich Svec

4,191
2
28
54

1

Could you tell Don, that since the F# developer\ enthusiast community is still pretty small, and the F# development team seems a bunch of pretty cool guys (in compiler developers standards), we would love to get some personal attention :-) – AK_ Apr 17 '13 at 15:12

"nested if" versus "if and" performance using F#

2 Answers2