.NET data structure efficiency

[udir]

Hi all,

When I moved to .NET I found out that all my Stl data structure where slown down. I wrote a little demo and find out that the same code run faster on Visual 6. I compared CArray Vs std::vector and my results were as following

CArray in .Net (atl::carray ? ) is 20% slower then in Visual 6 ( mfc::CArray ).

std::vector in .Net is 50% slower then in Visual 6.

Do the data structures I checked are much slower or did I do something wrong ???

Thanks, udi

p.s. here is the code I tested ( concole application using MFC )



// MfcVsStl.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include
#include "MfcVsStl.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// The one and only application object

CWinApp theApp;
#include

using namespace std;
class CMyClass
{
public:
CMyClass()
{
m_myIntMember = 0;
m_myString = "";
m_myArray.RemoveAll();
}

CMyClass(const CMyClass & other )
{
*this = other;
}

CMyClass & operator = (const CMyClass & other )
{
m_myIntMember = other.m_myIntMember;
m_myString = other.m_myString;

m_myArray.RemoveAll();
int dummy;
for (int i=0 ; i m_myArray;
CString m_myString;
};
typedef std::vector MyClassVecotr;
int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
int nRetCode = 0;

// initialize MFC and print and error on failure
if (!AfxWinInit(::GetModuleHandle(NULL), NULL, ::GetCommandLine(), 0))
{
// TODO: change error code to suit your needs
cerr << _T("Fatal Error: MFC initialization failed") << endl;
nRetCode = 1;
}
else
{
// TODO: code your application's behavior here.
CMyClass myClass;
myClass.m_myIntMember = 23847143;

for ( int i=0 ; i<1000 ; i++ )
{
myClass.m_myArray.Add(i);
}

myClass.m_myString = "Why is .Net so slow ???";
CArray udi;

MyClassVecotr udi2;
DWORD time1 = GetTickCount();
for ( i=0 ; i<500 ; i++)
{
udi2.push_back(myClass);
}

DWORD total2 = GetTickCount() - time1;
int dummy2 = 0;

time1 = GetTickCount();
for ( i=0 ; i<500 ; i++)
{
udi.Add(myClass);
}

DWORD total = GetTickCount() - time1;
int dummy = 0;
}

return nRetCode;
}

[Andreas Masur]

I heard about this issue several times already - mainly that most of the applications which gets updated to .NET are running slower than their equivalent compiled on Visual Studio 6.0.

I did not test it myself so I am still unsure whether it is right or not. I assume that you compiled unmanaged code with .NET though otherwise this might be responsible for the performance decrease...

[dude_1967]

Hello,

I often engage in run-time studies for pure number-crunching applications running in the emulated DOS console for both VC6 as well as VC7. The case studies involve various ultra-high precision calculations (such as 10^6 decimal digits of pi) written in highly-optimized C++ with a pure-C engine for FFT multiplication.

The test cases are written in pure C/C++ with no MFC support and no managed C++ support. The run-time critical algorithms do not typically make significant use of the STL.

The run-time performance of the code generated by VC7 is about 10% faster than VC6. GCC running in pure Linux without X-Windows is always about another 10% faster. I came to the conclusion that the optimizing compilers of VC7 are superior to those of VC6. This observation has been confirmed by test-runs using several other types of console applications.

Unfortunately, I do not have detailed results for the implementation of STL-vectors. However, I did make the observation (using a character-based, nested factorial calculation) that the implementation of ::std::string in VC7 is very fast---faster than VC6 and even faster than GCC 3.2.

I believe that there must be some run-time issues associated with the common language run-time environment for managed C++ and C# applications. The constraints put on the compiler are especially challenging for managed C++. If you look at the compiled assembler code for managed C++, you will find that although the compiler produces valid x86 assembly in Debug mode, the compiler creates pseudo-code for the common language run-time environment (CLR) in Release mode. In particular, the assembly files contain the comment: "; Generated by VC++ for Common Language Runtime".

The CLR probably needs a lot of work. However, it is unclear wheter or not optimized run-time characteristics are an established development goal for the .NET platform.

Chris.

:)

[Andreas Masur]

Originally posted by dude_1967
Hello,

I often engage in run-time studies for pure number-crunching applications running in the emulated DOS console for both VC6 as well as VC7. The case studies involve various ultra-high precision calculations (such as 10^6 decimal digits of pi) written in highly-optimized C++ with a pure-C engine for FFT multiplication.

<snipped>

Thank you very much for providing this useful information.

From what I get from your post you cannot verify any speed decrease of .NET for at least your kind of application. That is what I basically expected but I read and heard many other stories about that.

I am in the process to get .NET running to perform some testings myself but your results are looking optimistic... :cool:

[dude_1967]

Andreas,

I believe that managed C++ and C# are compiled not into target-based assembler, but rather into the new Microsoft intermediate assembly language (IL) which is a type of assembler-like pseudo code. The IL pseudocode can be interpreted within the common language runtime (CLR).

These programs run slow.

Pure, non-managed C++ is just fine---with, in fact significantly improved run-time performance compared with VC6, SP5. There are indications that the implementation of the STL-containers is well-optimized for run-time performance.

You can expect good run-time performance for your applications as long as you do not program the time-critical sequences using managed C++ or C#. I would like to find out about your experiences in this matter if you get a chance to do any performance testing.

Sincerely,
Chris.

P.S. There is a book which I intend to order soon. It seems to describe the IL and its role in the CLR:

http://www.amazon.com/exec/obidos/ASIN/0735615470/qid%3D1042013752/sr%3D11-1/ref%3Dsr%5F11%5F1/103-1695143-8556656

[indiocolifa]

anybody knows if VC7 can generate MMX/SSE/3DNow code automatically? (in either managed or unmanaged mode?)