45

When I read about the performance of JITted languages like C# or Java, authors usually say that they should/could theoretically outperform many native-compiled applications. The theory being that native applications are usually just compiled for a processor family (like x86), so the compiler cannot make certain optimizations as they may not truly be optimizations on all processors. On the other hand, the CLR can make processor-specific optimizations during the JIT process.

Does anyone know if Microsoft's (or Mono's) CLR actually performs processor-specific optimizations during the JIT process? If so, what kind of optimizations?

Improve this question
4
  • As far as I know, right now, not really. Commented Mar 8, 2010 at 22:44
  • 1
    A conspiracy theorist could also ponder whether MS could code the JIT to de-optimize if the software is running under a competitor's system, such as being virtualized on an x86 Mac, assuming they could detect that it was a Mac. Commented Mar 8, 2010 at 22:44
  • 8
    @aaronls: MacBU makes an estimated 350 million dollars a year in revenue for Microsoft. Macs are a profit center for Microsoft, which is the largest provider of Mac software in the world outside of Apple itself. How do these facts fit into your conspiracy theory? Commented Mar 9, 2010 at 2:06
  • 13
    @Eric Conspiracy theories are notorious for ignoring the facts. Commented Mar 9, 2010 at 14:36

7 Answers 7

Reset to default
28

From back in 2005, David Notario listed several specific targeted optimizations is his blog entry "Does the JIT take advantage of my CPU?". I can't find anything about the new CLR 4, but I imagine several new items are included.

Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

Wow. This is one nice find. +1
Quote from the blog: "we don't vectorize code (which is the real win with SSE2)". So sadly, JIT doesn't take much advantages.
@colinfang but it will soon: blogs.msdn.com/b/dotnet/archive/2014/04/07/…
8

One processor specific optimization I'm aware of that's done in Mono is compiling Mono.Simd calls down to SSE instructions on processors that support SSE. If the processor running the code doesn't support SSE, the JIT compiler will output the equivalent non-SSE code.

Improve this answer

Comments

2

The 32 and 64 bit Jitters are different, that's a start.

Improve this answer

2 Comments

As I understand the question, the OP is looking for processor-specific optimizations within a processor family (e.g. does it generate specific code depending the current processor is based on NetBurst vs. Core microarchitecture, both running in 32 bit mode?)
@Mehrdad, I know this was not the main direction but I thought it deserved a mention.
2

.Net Framework Runtime Optimization Service optimizes not just programming issues (compiler's optimization) but also for processors.

Improve this answer

Comments

2

I'll point out that the main reason that I hear cited for the potential of JIT-compiled languages to outperform statically compiled languages has nothing to do with processor specific instructions. Instead, it's that information about the dynamic state of the program can be used to optimize code paths. For instance, inline caching can be used to make virtual method calls roughly as fast as non-virtual method calls. Roughly, this works by assuming that at a particular call site the method is called only on a single type and emitting code that jumps directly to that implementation (and then rewriting the code if this assumption is not born out later).

Improve this answer

4 Comments

Does Microsoft's CLR perform inline caching?
@dewald - Not that I know of, but I believe that several Java VMs do. Since methods are not virtual by default in C# (as opposed to Java) I think that this was a lower priority for .NET. However, this is only one example of how optimizations can be made at runtime by a JIT that are hard or impossible to make statically.
@dewald - See stackoverflow.com/questions/1255803/… for more on the contrast between the CLR and JVM approaches.
Nowadays though a lot of C++ compilers can perform profile guided optimization, which can also do this sort of optimizations.
1

I think some Java compilers do, Microsoft .NET doesn't, and it only beats precompiled when you compare apples to oranges. Precompiled can ship with a library variants tuned to different CPUs (or more likely, different instruction sets) and the runtime check to pick which library to load is a lot cheaper than JIT. For example, mplayer does this (google for mplayer enable-runtime-cpudetection).

Improve this answer

2 Comments

Do you have a reference to support your claim that MS .NET doesn't? Not questioning it, just wondering if that's opinion or documented fact.
Well, it turns out that Microsoft .NET does a few optimizations based on instruction set but not particular CPU characteristics such as cache layout (blogs.msdn.com/davidnotario/archive/2005/08/15/451845.aspx). My point about precompiled code being able to use the same optimizations (and more that are too costly to find in a JIT compiler) still holds though.
0

I know the rules for whether or not to inline functions changes depending on the processor type (x86, x64). And of course the pointer sizes will vary depending on if it runs as 32-bit or 64-bit.

Improve this answer

1 Comment

Yeah, but pointer size always changes, no matter if you're using a traditional compiler or not.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.