Back to Questions
1.4k
views5
comments
A suggestion to allow writing performance-optimal code in F#
f#parallel

Hi F# Team,

As I have mentioned before, I'm still new to F#. However, what I've seen so far has given me an idea that could help F# guys develop applications optimized for performance.

Let's imagine a code alternative: Two blocks of code that do the exact same thing but in a different way (a situation that we've all encontered countless times). Which block should one choose?

One of the things that I find more frustrating is that, in most cases, it is not possible to know at design time (at least not for me, anyway) which block will execute faster so, except in very simple cases, I have to choose based on aesthetic criteria (conciseness, elegance, etc, as if the end user cared) or else write performance tests (which adds to the workload).

Now imagine that you could:

1.- Highlight the first block of code in the VS F# editor.

2.- Click *somewhere* and get a little form.

3.- In the form, select an integer in some "Number of Executions" control (let's say 1,000).

4.- Select a few statistics (let's say "Max", "Min", "Median", "Avg", "StdDev") out of a set of available ones.

5.- Click "Execute" in the form.

6.- The piece of code is executed 1,000 times in interactive mode and the resulting statistics are displayed somewhere.

7.- Repeat steps 1 to 6 for the second piece of code.

8.- Implement the block that executes faster and discard the other one.

I'd love to see something like this. Another important aspect, I suppose, is that this would also allow to compare execution times between parallel sequential versions of the same code "with the minimum of fuss and bother". Cool. Because F# can be executed on the fly in interactive mode, then I suppose it offers an ideal framework in which to implement some 'quick performance-comparer' like this.

I'm sure that there would be tons of others things to take into account, but hopefully the description above gives the main idea.

Thanks,

dfg

PS.- My apologies if something like this is already possible and I'm not aware of it.

.

Actually you can already do this, just without the clicks and forms.

Highlight your code and press Alt+Enter to send it to FSI. In the FSI window type the following:

1

> #time;;

Now invoke your function, and at the end it will output statistics about GC collections and execution time. If you want to do it 1,000 times instead of 1, type the following:

1

Seq.iter (fun _ -> my_func arg1 arg2 (*etc*)) [1..1000]

and the statistics will be about all 1,000 executions

By on 2/24/2009 2:27 PM ()

Brilliant, great stuff!

Thanks a lot,

dfg

By on 2/24/2009 2:33 PM ()

If you want to understand why your code runs slow or fast, use Reflector to have a look at what it compiles to. For simple stuff the number of heap allocations is often a good measure for comparing the relative performance of two code snippets doing the same work.

By on 2/24/2009 2:50 PM ()

A note of caution: beware measurements of anything other than Release-mode optimized code. Measuring well is not always trivial.

By on 2/24/2009 2:39 PM ()

A note of caution: beware measurements of anything other than Release-mode optimized code. Measuring well is not always trivial.

That reminds me. In the Visual Studio Project options, there's a way to specify "compilation flags" for F# interactive. One of the default ones is --optimize. Does this mean that FSI code is already release optimized?

By on 2/24/2009 3:01 PM ()

    Topic tags

    IntelliFactory Offices Copyright (c) 2011-2012 IntelliFactory. All rights reserved.
    Home | Products | Consulting | Trainings | Blogs | Jobs | Contact Us | Terms of Use | Privacy Policy | Cookie Policy     		Built with WebSharper