I think you should not expect this from MC++, it has never been optimized
that way, take a look at C++/CLI, this is the compiler that has the most
optimizations available at the IL level, but be warned some my produce
unverifiable IL, so when compiled with /clr:safe or /clr:pure, you don't get
the same level of IL optimization.

Sorry dropped on the floor I guess ;-)

http://www.grimes.demon.co.uk/dotnet/man_unman.htm

I have tried by hand tuning the IL produced by C#, in some cases this
resulted in an unverifiable assembly, in other cases the performance
advantage wasn't measurable and in some cases the result was a worse
performance level, even when producing shorter IL. The same thing happens
when compiling with /Ox in C++/CLI sometimes the resultant performance is
worse. So it's not that simple to produce better IL that also results in
better (and predictable) run-time performance.

Willy.

I'm I missing something? Seems like VC++ .Net is faster! VC++ 6.0 is even
faster.
I'm currently writing a program for a particle simulator. I've aleady written
one in VC++ 6.0. Now I'm busy writing an updated version in Visual Studio
2005 C#. During my development phase I noticed that calculations aren't as
zippy as I thought. So, I went and wrote a little benchmark program to test
some 3d vector calculations.

In C# the code is:
--------------------------------------------------------------------
namespace Benchmark
{
   class Program
   {
       static void Main(string[] args)
       {
           CVector position1 = new CVector(1, 2, 3);
           CVector position2 = new CVector(4, 6, 7);

           float x1 = 0, y1 = 0, z1 = 0;
           float x2 = 0, y2 = 0, z2 = 0;
           int loopCount = 90000000;

           DateTime start = DateTime.Now;
           float dist = 0;

           for (int x = 0; x < loopCount; x++)
           {
               position1.x = x1;
               position1.y = y1;
               position1.z = z1;

               position2.x = x2;
               position2.y = y2;
               position2.z = z2;

               x1 += 1;
               y1 += 2;
               z1 += 3;
               x2 += 3;
               y2 += 4;
               z2 += 5;

               CVector lenvec = (position1 - position2);
               dist += lenvec.Length() - 11.1f - 56.3f;
           }
           DateTime end = DateTime.Now;

           Console.WriteLine("Time: "+ end.Subtract(start).ToString());
           Console.WriteLine("Dist: " + dist.ToString());
           Console.ReadLine();

       }
   }
}
...
public class CVector
{
...
   public float Length()
   {

       float root = x*x + y*y + z*z;
       if(root>0)
           return (float)Math.Sqrt(root);
       else
           return 0;
       
   }
...
}
In C++ the code is:
--------------------------------------------------------------------
#include "stdafx.h"
#include "vector.h"

using namespace System;

#include <iostream>
#include <string>

using namespace std;

int main(array<System::String ^> ^args)
{
    float time=0;

    float x1=0,y1=0,z1=0;
    float x2=0,y2=0,z2=0;

                    int loopCount = 90000000;

    DateTime start = DateTime::Now.Now;
    float dist = 0;

   for (int x = 0; x < loopCount; x++)
   {
        CVector position1 = CVector(x1, y1, z1);
        CVector position2 = CVector(z2, y2, z2);
        x1+=1;
        y1+=2;
        z1+=3;
        x2+=3;
        y2+=4;
        z2+=5;

        CVector lenvec = (position1 - position2);
        dist += lenvec.Length() - 11.1f - 56.3f;

 }
    DateTime end = DateTime::Now.Now;

                    String ^ timelen = (end-start).ToString();
    String ^ totaldist = dist.ToString();

    Console::WriteLine(totaldist);
    Console::WriteLine(timelen);
    cin.get();

   return 0;
}
...
class CVector
{
...
    const float Length() const
    {
         float root = x*x + y*y + z*z;
         if(root)
            return (float)sqrt(root);
         else
            return 0;
    }
...

Machine used:
1.5 GHz Pentium 4

Test results:

for Visual Studio 2005 C# Express with "Release" and "Optimize Code"
17.53 seconds

for Visual Studio 2005 C++ Express with "Release" and options /Ox /Ot
8.51 seconds (9 seconds faster!)

for Visual Studio 6.0 C++  Professional with "Release" and "Maximum Speed" -
Native Code (of course)
4.14 seconds! (Even Faster!)

All are tested on the same machine. Anyone, give me an explaination.
I also tested with Visual Studio 2005 Professional. Could not determine
anything to catch up with VC6.0.
Why should I develop a particle simulator in C#, or in C++ .Net?
Am I missing something? Please Help.