CODEWITHSUNDEEP
c#c++performance
Steve
Steve

Reputation: 12054

Performance difference between C++ and C# for mathematics

I would like to preface this with I'm not trying to start a fight. I was wondering if anyone had any good resources that compared C++ and C# for mathematically intensive code? My gut impression is that C# should be significantly slower, but I really have no evidence for this feeling. I was wondering if anyone here has ever run across a study or tested this themselves? I plan on running some tests myself, but would like to know if anyone has done this in a rigorous manner (google shows very little). Thanks.

EDIT: For intensive, I mean a lot of sin/cos/exp happening in tight loops

Upvotes: 17

Views: 9105

Answers (9)

Henk Holterman
Henk Holterman

Reputation: 273854

You do not define "mathematically intensive" very well (understatement for: not at all).

An attempt to a breakdown:

  • For the basic Sin/Cos/Log functions I would not expect much difference.

  • For linear algebra (matrices) I would expect .NET to loose out, the (always enforced) bounds checking on arrays is only optimized away under some circumstances.

You will probably have to benchmark something close to your intended domain.

Upvotes: 6

Crashworks
Crashworks

Reputation: 41482

I have to periodically compare the performance of core math under runtimes and languages as part of my job.

In my most recent test, the performance of C# vs my optimized C++ control-case under the key benchmark — transform of a long array of 4d vectors by a 4d matrix with a final normalize step — C++ was about 30x faster than C#. I can get a peak throughput of one vector every 1.8ns in my C++ code, whereas C# got the job done in about 65ns per vector.

This is of course a specialized case and the C++ isn't naive: it uses software pipelining, SIMD, cache prefetch, the whole nine yards of microoptimization.

Upvotes: 14

Jerry Coffin
Jerry Coffin

Reputation: 490788

I haven't checked recently, but the last time I did check, Microsoft's license agreement for the .NET runtime required you to agree NOT to publish any benchmarks of its performance. That tends to limit the amount of solid information that gets published.

A few others have implied it, but I'll state it directly: I think you're engaging in (extremely) premature optimization -- or trying to anyway.

Edit: Doing a bit of looking, the license has changed (a long time ago, in fact). The current terms say you're allowed to publish benchmarks -- but only if you meet their conditions. Some of those conditions look (to me) nearly impossible to meet. For example, you can only publish provided: "your benchmark testing was performed using all performance tuning and best practice guidance set forth in the product documentation and/or on Microsoft's support Web sites". Given the size and number of Microsoft's web sites, I don't see how anybody stands a chance of being certain they're following all the guidance they might provide.

Although that web page talks about .NET 1.1, the newer licenses seem to refer back to it as well.

So, what I remembered was technically wrong, but effectively correct anyway.

Upvotes: 2

stonemetal
stonemetal

Reputation: 6208

For basic math library functions there won't be much difference because C# will call out to the same compiled code that C++ would use. For more interesting math that you won't find in the math library there are several factors that make C# worse. The Current JIT doesn't support SSE instructions that you would have access to in C++.

Upvotes: 1

wheaties
wheaties

Reputation: 35990

I think you're asking the wrong question. You should be asking if C++ on can beat out the .NET family of languages in mathematical computation. Have a gander at F# timing comparisons for Runge Kutta

Upvotes: 5

joemoe
joemoe

Reputation: 5904

There are extensive benchmarks here:

http://shootout.alioth.debian.org/u32q/benchmark.php?test=all&lang=csharp&lang2=gpp&box=1

Note this compares the Mono JIT to C++. AFIAK there are no extensive benchmarks of Microsoft's implementation out there, so almost everything you will hear is hearsay. :(

Upvotes: 5

Randolpho
Randolpho

Reputation: 56448

C# will be slower in general, but not significantly so. In some cases, depending on the structure of the code, C# can actually be faster, as JIT analysis can frequently improve the performance of a long-running algorithm.

Edit: Here's a nice discussion of C# vs C++ performance

Edit 2:

"In general" is not really accurate. As you say, the JIT compiler can actually turn your MSIL into faster native code that the C++ compiler because it can optimize for the hardware it is running on.

You must admit, however, that the act of JIT compiling itself is resource intensive, and there are runtime checks that occur in managed code. Pre-compiled and pre-optimized code will always be faster than just JITted code. Every benchmark comparison shows it. But long-running processes that can have a fair amount of runtime analysis can be improved over pre-compiled, pre-optimized native code.

So what I said was 100% accurate. For the general case, managed code is slightly slower than pre-compiled, pre-optimized code. It's not always a significant performance hit, however, and for some cases JIT analysis can improve performance over pre-optimized native code.

Upvotes: 13

Yakeen
Yakeen

Reputation: 2215

I would consider using Mono.Simd to accelerate some operations. The minus is that on MS runtime it's not accelerated.

Upvotes: 2

JaredPar
JaredPar

Reputation: 755587

For straight mathematical functions asking if C# is faster than C++ is not the best question. What you should be asking

Is the assembly produced by the CLR JITer more or less efficient than assembly generated by the C++ compiler

The C# compiler has much less influence on the speed of purely mathmatical operations than the CLR JIT does. It would have almost identical performance as other .Net languages (such as VB.Net if you turn off overflow checing).

Upvotes: 5

Related Questions