Back to General and Gameplay Programming

[.net] Very sad IL optimization. Am I missing something?

krum · 2006-06-07T11:31:13

I've been contemplating porting my game engine over to C# and the .NET platform from C++, and one of those things that has concerned me is the gratuitus use of pass-by-value. In the case of large value types, like a 4x4 matrix, a pass-by-value pattern can really slow things down if you do it a lot. One of the structs I looked at in particular was the Microsoft.DirectX.Matrix struct. Apparently there are no methods that support pass-by-reference and in fact as far as I can tell the language simply has no support to pass-by-reference with operators. The one thing that disturbed me the most is how the JIT compiles the simple Matrix.Multipy into machine code. As you can see from the example below which I took from the DBGCLR tool on a Release compiled source file, the JIT spams a bunch of movq instructions to copy the value of the Matrix value type. In a game engine you might not really do so many matrix multiplies that it makes a huge difference, but it seems to me that if we're going to move to .NET we still need to be able to squeeze as much as we can out of the runtime to hit the framerate targets that we have under load. My question is, am I missing something? Is there a better way? Write my own math library with methods that have pass-by-reference? After all the time I've spent tweaking to get the most out of it sometimes even hand writing SIMD code in assembler, all those movq instructions are bugging the heck out of me. Matrix m = Matrix.Identity; 00000035 lea ecx,[ebp+FFFFFF34h] 0000003b call dword ptr ds:[00ED5914h] 00000041 lea edi,[ebp-4Ch] 00000044 lea esi,[ebp+FFFFFF34h] 0000004a mov ecx,10h 0000004f rep movs dword ptr es:[edi],dword ptr [esi] Matrix n = Matrix.Identity; 00000051 lea ecx,[ebp+FFFFFEF4h] 00000057 call dword ptr ds:[00ED5914h] 0000005d lea edi,[ebp+FFFFFF74h] 00000063 lea esi,[ebp+FFFFFEF4h] 00000069 mov ecx,10h 0000006e rep movs dword ptr es:[edi],dword ptr [esi] n = Matrix.Multiply( n,m); 00000070 lea eax,[ebp+FFFFFF74h] 00000076 sub esp,40h 00000079 movq xmm0,mmword ptr [eax] 0000007d movq mmword ptr [esp],xmm0 00000082 movq xmm0,mmword ptr [eax+8] 00000087 movq mmword ptr [esp+8],xmm0 0000008d movq xmm0,mmword ptr [eax+10h] 00000092 movq mmword ptr [esp+10h],xmm0 00000098 movq xmm0,mmword ptr [eax+18h] 0000009d movq mmword ptr [esp+18h],xmm0 000000a3 movq xmm0,mmword ptr [eax+20h] 000000a8 movq mmword ptr [esp+20h],xmm0 000000ae movq xmm0,mmword ptr [eax+28h] 000000b3 movq mmword ptr [esp+28h],xmm0 000000b9 movq xmm0,mmword ptr [eax+30h] 000000be movq mmword ptr [esp+30h],xmm0 000000c4 movq xmm0,mmword ptr [eax+38h] 000000c9 movq mmword ptr [esp+38h],xmm0 000000cf lea eax,[ebp-4Ch] 000000d2 sub esp,40h 000000d5 movq xmm0,mmword ptr [eax] 000000d9 movq mmword ptr [esp],xmm0 000000de movq xmm0,mmword ptr [eax+8] 000000e3 movq mmword ptr [esp+8],xmm0 000000e9 movq xmm0,mmword ptr [eax+10h] 000000ee movq mmword ptr [esp+10h],xmm0 000000f4 movq xmm0,mmword ptr [eax+18h] 000000f9 movq mmword ptr [esp+18h],xmm0 000000ff movq xmm0,mmword ptr [eax+20h] 00000104 movq mmword ptr [esp+20h],xmm0 0000010a movq xmm0,mmword ptr [eax+28h] 0000010f movq mmword ptr [esp+28h],xmm0 00000115 movq xmm0,mmword ptr [eax+30h] 0000011a movq mmword ptr [esp+30h],xmm0 00000120 movq xmm0,mmword ptr [eax+38h] 00000125 movq mmword ptr [esp+38h],xmm0 0000012b lea ecx,[ebp+FFFFFEB4h] 00000131 call dword ptr ds:[00ED590Ch] 00000137 lea edi,[ebp+FFFFFF74h] 0000013d lea esi,[ebp+FFFFFEB4h] 00000143 mov ecx,10h 00000148 rep movs dword ptr es:[edi],dword ptr [esi]

General and Gameplay Programming Programming

Started by krum June 06, 2006 10:08 PM

11 comments, last by Arild Fines 17 years, 10 months ago

joanusdmentia

1,060

June 07, 2006 01:20 AM

Indeed, the JIT probably isn't optimizing at all. When running a debug session (even when it's a release build) the JIT will turn off (most, if not all) optimisations so that the code is A) readable and B) can be related back to the original source in a meaningful way. I have heard of there being away to force optimizations, but I can't for the life of me remember what it is.

"Voilà! In view, a humble vaudevillian veteran, cast vicariously as both victim and villain by the vicissitudes of Fate. This visage, no mere veneer of vanity, is a vestige of the vox populi, now vacant, vanished. However, this valorous visitation of a bygone vexation stands vivified, and has vowed to vanquish these venal and virulent vermin vanguarding vice and vouchsafing the violently vicious and voracious violation of volition. The only verdict is vengeance; a vendetta held as a votive, not in vain, for the value and veracity of such shall one day vindicate the vigilant and the virtuous. Verily, this vichyssoise of verbiage veers most verbose, so let me simply add that it's my very good honor to meet you and you may call me V.".....V

Cygon

1,219

June 07, 2006 05:54 AM

Have you tried ngen.exe yet?
MSIL code can be compiled in two ways:

- On the fly (JIT) when the application is executed, meaning the compiler needs to be quick for the program to appear on the screen without delay.

- Manually using the "native image generator" which you can find as C:\Windows\Microsoft.NET\Framework\v2.0.50272\ngen.exe. This compiler will compile the MSIL code to machine code and it *should* perform all the optimization you're expecting from a good C++ compiler.

-Markus-

Professional C++ and .NET developer trying to break into indie game development.
Follow my progress: http://blog.nuclex-games.com/ or Twitter - Topics: Ogre3D, Blender, game architecture tips & code snippets.

Arild Fines

968

June 07, 2006 11:31 AM

From http://msdn2.microsoft.com/en-us/library/ms241594.aspx:

When you debug a managed application, Visual Studio suppresses optimization of just-in-time (JIT) code by default. Suppressing JIT optimization means you are debugging non-optimized code. The code runs a bit slower because it is not optimized, but your debugging experience is much more thorough. Debugging optimized code is harder and recommended only if you encounter a bug that occurs in optimized code but cannot be reproduced in the non-optimized version.

JIT optimization is controlled in Visual Studio by the Suppress JIT optimization on module load option. You can find this option on the General page under the Debugging node in the Options dialog box.

This guy has some good stuff about the JIT: http://blogs.msdn.com/davidnotario/default.aspx

--AnkhSVN - A Visual Studio .NET Addin for the Subversion version control system.[Project site] [IRC channel] [Blog]

[.net] Very sad IL optimization. Am I missing something?

This topic is closed to new replies.

Popular Topics

Recommended Tutorials

[.net] Very sad IL optimization. Am I missing something?

This topic is closed to new replies.

Popular Topics

Recommended Tutorials

Reticulating splines