Back to General and Gameplay Programming

I need your opinion!!! ASM vs Plain C++

Jim Drygiannakis · 2003-02-01T20:39:07

I need your opinion or knowledge on a subject. The question in few words is : "Why my inline asm code, which is the same as the code that VC produce, is slower than the same without asm ?" Let me explain what i''m talking about. Yesterday, i found out that VC can export a listing file, with asm and source code in it, for a specific .c or .cpp file. So i compiled my Vector class with this option enabled, and i began to study the generated asm file. First of all, let me clear something. I am not an assembly guru or something, and the only things i know about assembly is how to do math calculations, and some other basic stuff (like searching a string for a char etc). That''s why i compiled the Vector class to study it. The first function i saw was the default constructor. This will be the func of my example. In plain c the constructor looked like this: GEVector3D::GEVector3D() { x = 0.0f; y = 0.0f; z = 0.0f; } When i compiled this thing, the asm output was: // Initialization stuff for the { ; 14 : x = 0; mov eax, DWORD PTR _this$[ebp] mov DWORD PTR [eax], 0 ; 15 : y = 0; mov ecx, DWORD PTR _this$[ebp] mov DWORD PTR [ecx+4], 0 ; 16 : z = 0; mov edx, DWORD PTR _this$[ebp] mov DWORD PTR [edx+8], 0 // deinitialization stuff for the } When i saw it, i reliazed that there was unnecessary mov instructions in it. So, i tried to rewrite it with inline asm, by calling only the necessary instructions. The result was this: GEVector3D::GEVector3D() { _asm { mov eax, DWORD PTR _this$[ebp] mov DWORD PTR [eax], 0 mov DWORD PTR [eax+4], 0 mov DWORD PTR [eax+8], 0 } } The generated listing file had the same init and uninit stuff for the two function versions. So i started to rewrite the whole class with inline asm. Then i made some kind of benchmark. It was a big loop, inside of which, there were some vector initialization (constructor), and some vector math like dot products and cross products, normalization etc. When i timed the loop with the inline asm version of code, it outputs: "Averange time for 10000 loops of 100 vectors calcs : 1.2 sec" and this was in the release version, with inline func substitution enabled. When i timed the same loop, with the same code for the calculations and for the timing, with the plain c code, the "Averange time for 10000 loops of 100 vectors calcs : 0.3 sec", always in the release version. How can it be explained?????? And if i am making some kind of mistake, in big asm functions (cross products, normalization etc.), why it is still slower, if i use only the small and confident functions(like constructors etc.)???????? I need your opinion on that. Because i''m trying to make my apps run faster, i need some advice on it. Thanks in advance for your attention, and forgive my terrible english. HellRaiZer HellRaiZer

General and Gameplay Programming Programming

Started by HellRaiZer February 01, 2003 07:42 AM

10 comments, last by HellRaiZer 21 years, 2 months ago

Raduprv

997

February 01, 2003 06:16 PM

quote:Original post by Anonymous Poster
Those movs you found unnecessary are infact not. They get executed at the same time becuase none of the relies on the other.

quote:
mov eax, DWORD PTR _this$[ebp]
mov DWORD PTR [eax], 0

mov ecx, DWORD PTR _this$[ebp]
mov DWORD PTR [ecx+4], 0

mov edx, DWORD PTR _this$[ebp]
mov DWORD PTR [edx+8], 0

Huh?

Height Map Editor | Eternal lands

[edited by - Raduprv on February 1, 2003 7:21:44 PM]

Eternal Lands (free, Open Source MMORPG)

trzy

100

February 01, 2003 08:39 PM

quote:
mov eax, DWORD PTR _this$[ebp]
mov DWORD PTR [eax], 0
mov ecx, DWORD PTR _this$[ebp]
mov DWORD PTR [ecx+4], 0
mov edx, DWORD PTR _this$[ebp]
mov DWORD PTR [edx+8], 0

This is not good code. Your code did look better.

I''d be interested in seeing the complete listing after you added the inline assembly (as someone pointed out, perhaps something is being generated before and after the inline block?) I don''t use inline assembly, so I''m not too familiar with how MSVC handles it.

The key to acheiving instruction-level parallelism on modern OOO processors as I understand them is to eliminate dependency chains. Putting as many instructions which can be executed simultaneously without side effects close together is a good idea.

Don''t overestimate MSVC''s optimizer or any optimizer for that matter. Use assembly where it would really make an improvement (profile!) and make sure that you do a good job of it. Personally, I prefer having separate assembly source files so as to keep my C code as easily portable as possible.

----
Bart

----Bart

I need your opinion!!! ASM vs Plain C++

This topic is closed to new replies.

Popular Topics

Recommended Tutorials

I need your opinion!!! ASM vs Plain C++

This topic is closed to new replies.

Popular Topics

Recommended Tutorials

Reticulating splines