Comments on .NET tips, tricks and patterns: The cost of method calls

A report about mentioned issue with performance of...

2009-02-22T18:43:52.960+05:00

A report about mentioned issue with performance of VGM calls on interface: https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=91710

An overview of implementation of virtual generic m...

2009-02-22T18:41:11.689+05:00

An overview of implementation of virtual generic method call in Mono: http://schani.wordpress.com/2008/10/12/fast-virtual-generic-calls/

Copying recent discussion of this post by e-mail:Q...

2008-11-01T21:29:17.902+05:00

Copying recent discussion of this post by e-mail:

Q: Hello Alex,

I have read your blog post "The cost of method calls". It's very interesting. I was very surprised on the cost of virtual generic method call. Isn't there any difference between using reference vs value type parameters on the type or method?

A:

I suspect there can be noticeable difference: since actually there is just one JITted version of method emitted for any reference type, theoretically it can be found much faster (i.e. without a hash table lookup).

On the other hand, generic methods are practically much more interesting for value types... For reference types they bring only better safety & readability. That's why we measured this for value types only.

So just measured:

Virtual generic call test (1 generic argument: Int32):
Type: Int32
Measurement: Generic method 1 (class) 65,500 M/s.
Measurement: Generic method 1 (class, by delegate) 403,042 M/s.
Measurement: Generic method 1 cast (class) 42,202 M/s.
Measurement: Generic method 1 (interface) 65,523 M/s.
Measurement: Generic method 1 (interface, by delegate) 405,369 M/s.
Measurement: Generic method 1 cast (interface) 609,802 K/s.
Virtual generic call test (1 generic argument: String):
Type: String
Measurement: Generic method 1 (class) 51,888 M/s.
Measurement: Generic method 1 (class, by delegate) 308,143 M/s.
Measurement: Generic method 1 cast (class) 444,508 K/s.
Measurement: Generic method 1 (interface) 51,326 M/s.
Measurement: Generic method 1 (interface, by delegate) 309,349 M/s.
Measurement: Generic method 1 cast (interface) 443,909 K/s.

Conclusions:
- The difference is generally neglectable. May be we should try putting "where T: class" constraint on such methods to make JITter to think about this a bit more? ;)
- Again, it seems there is a serious bug in delegate creation (see bold italicized results in "... cast" lines).

I agree with this. Anonymous delegates are frequen...

2008-10-29T13:46:55.836+05:00

I agree with this. Anonymous delegates are frequently not cached, and in such cases construction of their instances is rather costly. Let's estimate this:

- .NET creates an anonymous type to handle such a delegate. Its construction cost is ~ 3.5 in comparison to VM call.
- Then it creates a delegate pointing to its method. The cost is ~ 7.5.
- Finally, it invokes it. The cost is 1.5, assuming invocation happens just once (i.e. the worst, but most likely the most common case).

So if anonymous delegate is called just once, you're getting ~ 8.5 times slower call in case it isn't cached.

In general this isn't "to bad" - i.e. you should have about 50M invocations \ second in such a case. This is anyway much more then such languages as Ruby or Python may provide. But less then 400M with a regular delegate, of course ;)

Btw, this is enough for the most of RDBMS \ BLL related tasks. It was shown that peak speed of data extraction with ORM is about 400K instances per second, i.e. 100 times slower. So using such anonymous delegates won't seriously affect on performance in such cases.

But if I develop a game on C#, or something else requiring real-time computing, I would seriously care about this.

Good stuff, Alex.What do you think of functional-s...

2008-10-29T13:14:44.029+05:00

Good stuff, Alex.

What do you think of functional-style programming in C# 3.0 and anonymous delegates? It seems that it will generate slower programs without the developer's knowledge... It is maybe the natural path from a low-level and efficient programming language to a high-level and low one :(.

-gael

Forgot to add: the code for all these tests can be...

2008-10-29T12:29:56.083+05:00

Forgot to add: the code for all these tests can be found in DataObjects.Net 4.0 test suite, see "Xtensive.Core\Xtensive.Core.Tests\DotNetFramework\".

Any comments are welcome.