WHy is C# so much slower than c++???

[jimocz]

Did I do something wrong? I cross posted this on the dotnet
development group -- sorry if it is a double posting but we are
seriously considering going to c# and this could be a show stopper.

I ran the following C# program and it ran in 9 seconds (give or take 1
sec)

using System;
using System.Collecti ons.Generic;
using System.Text;

namespace DotProduct1Mill ion
{
class Program
{
static void Main(string[] args)
{

double d1 = 0.727272;
double d2 = 0.26252;
double d3 = 343432.232;
Console.WriteLi ne(" {0}", System.DateTime .Now);
for (long i = 0; i < 2000000000; i++)
{
d3 = d1 * d2;
d1 = d3 * d2;
d2 = d2 * d2;
d3 = d1 * d2;
d3 = d3 * d2;
}
Console.WriteLi ne(" {0}", System.DateTime .Now);
}
}

}

I ran the following C++ program -- it ran in under 1 second. Is C#
really that much slower than C++????
What is the problem here?

#include <iostream>
#include <cstdlib>
#include <ctime>

using namespace std;

int main(int argc,char *argv[])
{
double d1 = 0.727272;
double d2 = 0.26252;
double d3 = 343432.232;

cout << time(NULL) << endl;

for (long i = 0; i < 2000000000; i++)
{

d3 = d1 * d2;
d1 = d3 * d2;
d2 = d2 * d2;
d3 = d1 * d2;
d3 = d3 * d2;
}
cout << time(NULL) << endl;

[jimocz]

okay -- chnaged some code a bit:
double d1 = 0.92;
double d2 = 1.34;
double d3 = 1.0;
Console.WriteLi ne(" {0}", System.DateTime .Now);
for (long i = 0; i < 2000000000; i++)
{
d3 = d1 * d2;
d1 = d3 * d2;
d2 = d2 * d2;
d3 = d1 * d2;
d3 = d3 * d2;
if (d1 1.0e10) d1 = 9.0;
if (d2 9e10) d2 = 1.6;
This makes the times 12.6 secs for C++ and 15-16 seconds for C#.
Much more reasonable.
I suspect there was an underflow/overflow situation and the C++ code
stopped executing.

Still C# is still ~ 20% slower than C++. Managed C++ too!

jimocz wrote:

Did I do something wrong? I cross posted this on the dotnet
development group -- sorry if it is a double posting but we are
seriously considering going to c# and this could be a show stopper.

I ran the following C# program and it ran in 9 seconds (give or take 1
sec)

using System;
using System.Collecti ons.Generic;
using System.Text;

namespace DotProduct1Mill ion
{
class Program
{
static void Main(string[] args)
{

double d1 = 0.727272;
double d2 = 0.26252;
double d3 = 343432.232;
Console.WriteLi ne(" {0}", System.DateTime .Now);
for (long i = 0; i < 2000000000; i++)
{
d3 = d1 * d2;
d1 = d3 * d2;
d2 = d2 * d2;
d3 = d1 * d2;
d3 = d3 * d2;
}
Console.WriteLi ne(" {0}", System.DateTime .Now);
}
}

}

I ran the following C++ program -- it ran in under 1 second. Is C#
really that much slower than C++????
What is the problem here?

#include <iostream>
#include <cstdlib>
#include <ctime>

using namespace std;

int main(int argc,char *argv[])
{
double d1 = 0.727272;
double d2 = 0.26252;
double d3 = 343432.232;

cout << time(NULL) << endl;

for (long i = 0; i < 2000000000; i++)
{

d3 = d1 * d2;
d1 = d3 * d2;
d2 = d2 * d2;
d3 = d1 * d2;
d3 = d3 * d2;
}
cout << time(NULL) << endl;

[Bruno van Dooren [MVP VC++]]

This makes the times 12.6 secs for C++ and 15-16 seconds for C#.

Much more reasonable.
I suspect there was an underflow/overflow situation and the C++ code
stopped executing.

Still C# is still ~ 20% slower than C++. Managed C++ too!

Hi,
enable the optimizer in your C# project settings. It is disabled by default.
Then the C++.NET and C# results should be nearly identical.
Native C++ will probably a bit faster dues to lower memory overhead.

For more accurate timing you should use the StopWatch class, and not include
the Console.WriteLi ne statements in your time measurements. That will give
you ms accuracy or better.

As far as switching to C# goes: from personal experience I can say that
application development times and debugging times are much shorted in C#
than in native C++ or even C++.NET.
YMMV.

--

Kind regards,
Bruno van Dooren
br************* *********@hotma il.com
Remove only "_nos_pam"

[Willy Denoyette [MVP]]

for(long i = 0...
in C#
and
for(long i = 0...
in C++ are not the same loops. A long in C# is 64 bit while in C++ it's a
32bit value.
Make i an int and you'll see that both will run at the same speed.
Willy.

"jimocz" <dw****@gmail.c omwrote in message
news:11******** **************@ k70g2000cwa.goo glegroups.com.. .
| okay -- chnaged some code a bit:
| double d1 = 0.92;
| double d2 = 1.34;
| double d3 = 1.0;
| Console.WriteLi ne(" {0}", System.DateTime .Now);
| for (long i = 0; i < 2000000000; i++)
| {
| d3 = d1 * d2;
| d1 = d3 * d2;
| d2 = d2 * d2;
| d3 = d1 * d2;
| d3 = d3 * d2;
| if (d1 1.0e10) d1 = 9.0;
| if (d2 9e10) d2 = 1.6;
|
|
| This makes the times 12.6 secs for C++ and 15-16 seconds for C#.
| Much more reasonable.
| I suspect there was an underflow/overflow situation and the C++ code
| stopped executing.
|
| Still C# is still ~ 20% slower than C++. Managed C++ too!
|
|
|
| jimocz wrote:
| Did I do something wrong? I cross posted this on the dotnet
| development group -- sorry if it is a double posting but we are
| seriously considering going to c# and this could be a show stopper.
| >
| I ran the following C# program and it ran in 9 seconds (give or take 1
| sec)
| >
| using System;
| using System.Collecti ons.Generic;
| using System.Text;
| >
| namespace DotProduct1Mill ion
| {
| class Program
| {
| static void Main(string[] args)
| {
| >
| double d1 = 0.727272;
| double d2 = 0.26252;
| double d3 = 343432.232;
| Console.WriteLi ne(" {0}", System.DateTime .Now);
| for (long i = 0; i < 2000000000; i++)
| {
| d3 = d1 * d2;
| d1 = d3 * d2;
| d2 = d2 * d2;
| d3 = d1 * d2;
| d3 = d3 * d2;
| }
| Console.WriteLi ne(" {0}", System.DateTime .Now);
| }
| }
| >
| }
| >
| I ran the following C++ program -- it ran in under 1 second. Is C#
| really that much slower than C++????
| What is the problem here?
| >
| #include <iostream>
| #include <cstdlib>
| #include <ctime>
| >
| using namespace std;
| >
| int main(int argc,char *argv[])
| {
| double d1 = 0.727272;
| double d2 = 0.26252;
| double d3 = 343432.232;
| >
| cout << time(NULL) << endl;
| >
| for (long i = 0; i < 2000000000; i++)
| {
| >
| d3 = d1 * d2;
| d1 = d3 * d2;
| d2 = d2 * d2;
| d3 = d1 * d2;
| d3 = d3 * d2;
| }
| cout << time(NULL) << endl;
|

[Shawn B.]

Hi,

enable the optimizer in your C# project settings. It is disabled by
default.
Then the C++.NET and C# results should be nearly identical.
Native C++ will probably a bit faster dues to lower memory overhead.

For more accurate timing you should use the StopWatch class, and not
include the Console.WriteLi ne statements in your time measurements. That
will give you ms accuracy or better.

In addition, you might try running the loop once to warm up and JIT the
code, and then do your test once it has been fully JITd, since you're probly
seeing a certain amount of "warm-up" time while the IL code gets compiled
and it makes things looks slower (for such a small program its probly not
noticeable but still)... as well, run it RELEASE mode and not DEBUG mode...

You might also want to try changing the code to:

static void Main(string[] args)
{
double d1 = 0.727272;
double d2 = 0.26252;
double d3 = 343432.232;
Console.WriteLi ne(" {0}", System.DateTime .Now);

unchecked
{
for (long i = 0; i < 2000000000; i++)
{
d3 = d1 * d2;
d1 = d3 * d2;
d2 = d2 * d2;
d3 = d1 * d2;
d3 = d3 * d2;
}
}
Console.WriteLi ne(" {0}", System.DateTime .Now);
}

By default the numerical operations are _checked_ which means the the
runtime will check for overflows. Changing it to unchecked in C# eliminates
that extra check and puts it on par with what the C++ code is actually
doing. You can change it in the project also (globally) but the code above
is just fine. I prefer to unchecked {...} my code where needed for the sake
of clarity when reading the code later.
Thanks,
Shawn

[Shawn B.]

Actually, executing the code in checked {...} vs. unchecked {...} really
doesn't make a whole lot of difference. However, running it in DEBUG (with
or without debugging) vs. RELEASE makes a huge difference.

For example, running in DEBUG with debugging takes 380 seconds, DEBUG
without debugging takes 56 seconds, and RELEASE without debugging takes 14
seconds.

The first iteration includes the JIT time and the second iterations is
already JIT'd.
Thanks,
Shawn


using System;
using System.Collecti ons.Generic;
using System.Text;

namespace ConsoleApplicat ion1
{
class Program
{
private static void Main(string[] args)
{

for (int i = 0; i < 2 ; i++)
{
Console.WriteLi ne("Iteration {0} of 2", (i + 1));

Test1();
Test2();
}
Console.ReadLin e();
}

private static void Test1()
{
double d1 = 0.727272;
double d2 = 0.26252;
double d3 = 343432.232;

System.Diagnost ics.Stopwatch watch = new System.Diagnost ics.Stopwatch() ;
watch.Start();

checked
{
for (long i = 0; i < 2000000000; i++)
{
d3 = d1 * d2;
d1 = d3 * d2;
d2 = d2 * d2;
d3 = d1 * d2;
d3 = d3 * d2;
}
}

watch.Stop();

Console.WriteLi ne("Test1: " + watch.Elapsed.T otalSeconds.ToS tring());
}

private static void Test2()
{
double d1 = 0.727272;
double d2 = 0.26252;
double d3 = 343432.232;

System.Diagnost ics.Stopwatch watch = new System.Diagnost ics.Stopwatch() ;
watch.Start();

unchecked
{
for (long i = 0; i < 2000000000; i++)
{
d3 = d1 * d2;
d1 = d3 * d2;
d2 = d2 * d2;
d3 = d1 * d2;
d3 = d3 * d2;
}
}

watch.Stop();

Console.WriteLi ne("Test2: " + watch.Elapsed.T otalSeconds.ToS tring());
}

}
}

[Willy Denoyette [MVP]]

As I said in another reply, you should make the loop counter an int instead
of a long (2000000000 fits in an int), incrementing a long (64 bit value in
C#) is more expensive than incrementing an int on a 32 bit CPU.
Also, when comparing C# performance against C++, you should keep in mind
that a long in C++ != long in C#.

Willy.

"Shawn B." <le****@html.co mwrote in message
news:ev******** ******@TK2MSFTN GP03.phx.gbl...
| Actually, executing the code in checked {...} vs. unchecked {...} really
| doesn't make a whole lot of difference. However, running it in DEBUG
(with
| or without debugging) vs. RELEASE makes a huge difference.
|
| For example, running in DEBUG with debugging takes 380 seconds, DEBUG
| without debugging takes 56 seconds, and RELEASE without debugging takes 14
| seconds.
|
| The first iteration includes the JIT time and the second iterations is
| already JIT'd.
|
|
| Thanks,
| Shawn
|
|
|
|
| using System;
| using System.Collecti ons.Generic;
| using System.Text;
|
| namespace ConsoleApplicat ion1
| {
| class Program
| {
| private static void Main(string[] args)
| {
|
| for (int i = 0; i < 2 ; i++)
| {
| Console.WriteLi ne("Iteration {0} of 2", (i + 1));
|
| Test1();
| Test2();
| }
|
|
| Console.ReadLin e();
| }
|
| private static void Test1()
| {
| double d1 = 0.727272;
| double d2 = 0.26252;
| double d3 = 343432.232;
|
| System.Diagnost ics.Stopwatch watch = new System.Diagnost ics.Stopwatch() ;
| watch.Start();
|
| checked
| {
| for (long i = 0; i < 2000000000; i++)
| {
| d3 = d1 * d2;
| d1 = d3 * d2;
| d2 = d2 * d2;
| d3 = d1 * d2;
| d3 = d3 * d2;
| }
| }
|
| watch.Stop();
|
| Console.WriteLi ne("Test1: " + watch.Elapsed.T otalSeconds.ToS tring());
| }
|
| private static void Test2()
| {
| double d1 = 0.727272;
| double d2 = 0.26252;
| double d3 = 343432.232;
|
| System.Diagnost ics.Stopwatch watch = new System.Diagnost ics.Stopwatch() ;
| watch.Start();
|
| unchecked
| {
| for (long i = 0; i < 2000000000; i++)
| {
| d3 = d1 * d2;
| d1 = d3 * d2;
| d2 = d2 * d2;
| d3 = d1 * d2;
| d3 = d3 * d2;
| }
| }
|
| watch.Stop();
|
| Console.WriteLi ne("Test2: " + watch.Elapsed.T otalSeconds.ToS tring());
| }
|
| }
| }
|
|

[jimocz]

Okay,
I am running in release mode and I have changed the longs to doubles as
seen here:
#include <iostream>
#include <cstdlib>
#include <ctime>

using namespace std;

int main(int argc,char *argv[])
{
double d1 = 0.92;
double d2 = 1.34;
double d3 = 1.0;
double i;

float now = clock()/(float)CLOCKS_P ER_SEC;
for (i = 0; i < 6000000000.0; i+= 1.0)
{

d3 = d1 * d2;
d1 = d3 * d2;
d2 = d2 * d2;
d3 = d1 * d2;
d3 = d3 * d2;
if (d1 1.0e10) d1 = 9.0;
if (d2 9e10) d2 = 1.6;

}
cout << "i = " << i << " Time to run CPP ==" <<
(clock()/(float)CLOCKS_P ER_SEC - now) << endl;

}
AND the C# code ::
using System;
using System.Collecti ons.Generic;
using System.Text;
using System.Diagnost ics;

namespace DotProduct1Mill ion
{
class Program
{

static void Main(string[] args)
{
Stopwatch sw;
double d1 = 0.92;
double d2 = 1.34;
double d3 = 1.0;

sw = new Stopwatch();
sw.Start();

for (double i = 0; i < 6000000000.0; i+= 1.0)
{
d3 = d1 * d2;
d1 = d3 * d2;
d2 = d2 * d2;
d3 = d1 * d2;
d3 = d3 * d2;
if (d1 1.0e10) d1 = 9.0;
if (d2 9e10) d2 = 1.6;

}
sw.Stop();
TimeSpan ts = sw.Elapsed;
string s = String.Format(" {0:00}:{1:00}.{ 2:000}",
ts.Minutes, ts.Seconds,
ts.Milliseconds );

Console.WriteLi ne("Time with C# = {0}", s);
}
}
}

I have included the if statements to avoid any underflow/overflow
stuff.

The interesting thing is if I turn off optimization the C# code runs
faster. (81 secs to 121 secs)
However, if I turn on optimization the C++ code runs in 45 secs and C#
drops to 61 secs. I guess the C++ compiler is smarter than the C#
compiler!?

Thanks to all for the suggestions and help.

Jim

[Bruno van Dooren [MVP VC++]]

The interesting thing is if I turn off optimization the C# code runs

faster. (81 secs to 121 secs)
However, if I turn on optimization the C++ code runs in 45 secs and C#
drops to 61 secs. I guess the C++ compiler is smarter than the C#
compiler!?

Be aware that you are comparing apples and oranges.
IF you would compare C# with a C++/CLI application, they would be nearly
identical.
Number crunching is almost always going to be faster in a native
application.

--

Kind regards,
Bruno van Dooren
br************* *********@hotma il.com
Remove only "_nos_pam"

[jimocz]

You are right on -- I compiled the C++ as managed code (I assume that
is CLI) and it was around 62 seconds.

This begs the question why is managed code so much slower than native?
I know you JIT compile it (that shouldn't affect the times since the
compile time is not included in the time) but is running in the virtual
machine following JIT 30% slower?

I suppose this is a major reason to maintain native C++ code --
computations.

Bruno van Dooren [MVP VC++] wrote:

The interesting thing is if I turn off optimization the C# code runs
faster. (81 secs to 121 secs)
However, if I turn on optimization the C++ code runs in 45 secs and C#
drops to 61 secs. I guess the C++ compiler is smarter than the C#
compiler!?

Be aware that you are comparing apples and oranges.
IF you would compare C# with a C++/CLI application, they would be nearly
identical.
Number crunching is almost always going to be faster in a native
application.

--

Kind regards,
Bruno van Dooren
br************* *********@hotma il.com
Remove only "_nos_pam"