What's the right approach to writing a tight array loop in F#? No matter what I do, I can't seem to make F# generate IL that the JIT will optimize correctly. I'm comparing this F#:

1
2
3

let setAll (xs : int array) v =
    for i = 0 to Array.length xs - 1 do
        xs.[ i ] <- v

to this C#:

1
2
3
4
5

static void SetAll(int[] xs, int v) {
    for (int i = 0; i < xs.Length; i++) {
        xs[ i ] = v;
    }
}

They should be identical, right? F# generates a fair amount more IL and does things like saves the array length in a local. It boils down to making the CLR's JIT not being able to optimize the loop. Here's the x86 (.NET 3.5SP1) I get for the F# version:

00000035 cmp eax,ecx
00000037 jae 00000095
00000039 mov dword ptr [esi+eax*4+8],1
00000041 inc eax
00000042 cmp eax,edx
00000044 jl 00000035

and for C#:

0000002e mov dword ptr [esi+edx*4+8],1
00000036 inc edx
00000037 cmp ecx,edx
00000039 jg 0000002E

The extra compare and jump must be killing it, since the F# version takes over twice the time to complete (10000 calls to setAll on an array of 200000):

1
2
3
4

let xs = Array.create 200000 0
let sw = Diagnostics.Stopwatch.StartNew()
for i = 0 to 10000 do setAll xs 1
printfn "%A" sw.ElapsedMilliseconds

I looked in the F# source, and the array code (local.fs) uses the same pattern, only it usually manually caches the length of the array. This made no difference in my tests.

As a side note, the Mono 2.2 32-bit JIT on Windows performed the same with C# and F# (as slow as F# in the CLR's).

Any suggestions?