Home
Reading
Searching
Subscribe
Sponsors
Statistics
Posting
Contact
Spam
Lists
Links
About
Hosting
Filtering
Features Download
Marketing
Archives
FAQ
Blog
 
Gmane
From: Jonathan Pryor <jonpryor <at> vt.edu>
Subject: Re: C# to x86 assembly code?
Newsgroups: gmane.comp.gnome.mono.devel
Date: Tuesday 19th September 2006 00:30:54 UTC (over 10 years ago)
On Mon, 2006-09-18 at 14:27 -0500, Jonathan Gilbert wrote:
> At 08:44 PM 18/09/2006 +0200, Marcos  wrote:
> >Hi Auge,
> >
> >You can currently use Mono AOT compilation (Ahead-Of-Time; "mono
> >--aot" I think) in order to get a precompiled binary, It'll cause your
> >application to run faster, between some other things.
> 
> More specifically, it will cause the application to start up faster. The
> actual run speed in practice shouldn't be noticeably different from
> on-the-fly JITted code. It's the same engine, after all, emitting the
code.
> :-)

More specifically, it *might* speed things up, and it might not.

There was a .NET developer blog (last year?) that did some timing
analysis for .NET, and found that for *cold* starts, the JIT was
_faster_ than NGEN-generated code (the equivalent of `mono --aot`).
Why?  Because IL is smaller than x86 assembly, so less data needed to be
read from disk, and the JIT was fast enough that it didn't slow things
down in that case.

On the flip side, for *warm* starts (i.e. the NGEN code was already in
the OS disk cache), NGEN code was faster than JIT code (as the OS didn't
have to hit the disk).

Then there are other issues (the JIT can do direct method calls, while
NGEN/AOT code needs to go through an indirection for each method
invocation so that the assembly loader can fixup method addresses, just
like with normal Win32 DLLs and ELF shared libraries).

So the only way to know for sure which is faster is to test.

 - Jon
 
CD: 3ms