Towards my previous performance posts:

Shawn Hargreaves wrote a post describing the way good microbenchmarking of language or platform features should be performed. As I can see, he likes idea of using LINQ for mean and variance calculations too :)

Have you read my post about LINQ performance? Well, are you interested in how quick is the C++ code that perform exactly the same thing? You’ll get the answer right now:

C++ mean: 0.500 var: 0.0833 time: 3.962 sec

So, again, why C# is slow? =)

UPDATE (July 31, 2009):

I’m just a stupid guy who has accidentally (I swear!) passed really huge array parameter by value (!) twice (!!!). Fixing myself:

C++ mean: 0.500 var: 0.0833 time: 1.888 sec

I have another question now. Why the hell is C# code doing exactly the same thing (in a way that seems effective to me) so slow compared to its C++ analogue? Is it JIT compilation overhead for those two functions? Nope. Checked it. Probably, JIT optimizer sucks? But what can C++ optimizer do what .NET JIT can not in the case of simple sequential access? Maybe access through enumerator is less effective than indexing? And here we go:

Indexing: mean=0,5000 var=0,0833 time=00:00:00.7956019

It’s more than two times faster than the C++ version! And more than 3 times faster than the one that uses enumerators in C#! Currently looking for explanation…

UPDATE 2 (July 31, 2009):

Well, .NET JITer is not as smart as I think it is. It looks like foreach applied to array actually executes all that enumerator-related stuff while the most simple for loop is heavily optimized.

I really like LINQ feature in .NET. For me it’s what people call syntactic sugar. It allows me to reduce amount of code I’m writing dramatically in many cases. Look at the following example - http://pastebin.com/d10c04029

This code estimates mean and variance of distribution given a sequence of samples. Two versions are provided. The first one uses .NET 2.0 features only and the second uses LINQ. As you can see, LINQ version is very short and awesome-looking even for this very simple example.

Are there any drawbacks? Yeah, unfortunately. And, of course, that drawbacks are performance related. Let’s compare time required for processing sequence (System.Array of double) containing 50 million samples (drawn from [0,1]-uniform distribution if that matter something for someone):

Normal: mean=0,5000 var=0,0833 time=00:00:03.6591708
LINQ: mean=0,5000 var=0,0833 time=00:00:04.5832141

Why is the LINQ version 1.5 times slower? Well, the obvious answer is that it should call a function (which is not inlined) for every member of the sequence, at least while calculating variance, and the first version should not. And, probably, computational cost of a function call is comparable to a few math operations (as it should be). So, use LINQ as a syntactic sugar only when the function you want to apply to the sequence elements is much more complex than a few additions and multiplications or when your collection is small and you just don’t care about processing time.

Read more about LINQ performance there - http://davepeck.org/linq-collection-performance/.

Strange observation: when passing List<double> instead of array, LINQ version takes about 6 seconds while performance of the normal version does not change.

I totally hate C++. And every day my hate grows up. But that is not just about my programming language religion. We should look deeper.

for (std::vector<double>::iterator it = values.begin();
    it != values.end();
    ++it)
 DoStuff(*it);

foreach (double value in values)
 DoStuff(value);