What are the different types of jit compilers?

NET there are three types of JIT (Just-In-Time) compilers which are Explained as Under,

• Pre-JIT Compiler (Compiles entire code into native code completely)
• Econo JIT Compiler (Compiles code part by part freeing when required)
• Normal JIT Compiler (Compiles only that part of code when called and places in cache.

Different Types of JIT

1. Pre JIT Compiler
2. Econo JIT Compiler
3. Normal JIT Compiler

PRE JIT Compiler compiles complete source code into native code in a single compilation cycle. It is done through NGen (the process of precompiling from CIL to a native image). It will convert the compiled .NET code from the platform-independent intermediate state to a platform specific stage. This means that, it converts the .NET application that can run on both Windows, Mac and Linux 32-bit and 64-bit to an traditional EXE file that can only run on one of these.

The advantage of PRE JIT Compiler is that you don't have the initial compilation delay that the compiler can introduce when an assembly or type is loaded for the first time in code. It improves the warm startup time of your program. A warm start is one where the assembly data is already in the file system cache so no time is spent by the disk drive to locate the DLL on the disk. As opposed to a cold start, one you'll get when the assembly has never been loaded before or was loaded long ago, the disk drive has to find the file first. Which is slow. You almost always only care about cold start times because that's the one that's so noticeable to the user.

Econo JIT Compiler compiles only those methods that are called at runtime. However, these compiled methods are removed when they are not required. The idea of Econo JIT is to spend less time compiling so that startup latency is lower for interactive applications. This is actually what you want once you notice the app takes seconds to start up.

Normal-JIT compiles only those methods that are called at runtime . After execution this method is stored in the memory and it is commonly referred as "jitted" . No further compilation is required for the same method. Subsequent method calls are accessible directly from the memory cache.

https://www.c-sharpcorner.com/UploadFile/nipuntomar/jit-just-in-time-compiler/#:~:text=NET%20there%20are%20three%20types,called%20and%20places%20in%20cache

Normal Jit:- 

1. It is enabled by default

2.It compiles the code on demand (when you run the app and perform some action like button click and not when you build the project)(ex:- button click then code inside button click event will be compiled to machine code) and saves the compiled version into Memory (RAM).

Pre-Jit (ngen.exe)

1. It can be set to execute any assembly from cmd prompt using ngen.exe

2. It will compile the whole project when you will build the project for the very first time and there will be no jitting at run time (when you run the app)

Eco-jit :-

It is by default enabled for mobile app but not for web apps, considering Less RAM so cashing wouldn't be required.

NET there are three types of JIT (Just-In-Time) compilers which are Explained Under,

Pre-JIT Compiler (Compiles entire code into native code completely)

Econo JIT Compiler (Compiles code part by part freeing when required)

Normal JIT Compiler (Compiles only that part of code when called and places it in the cache.

Hello Naresh,

https://www.c-sharpcorner.com/UploadFile/nipuntomar/jit-just-in-time-compiler/

https://www.c-sharpcorner.com/UploadFile/8911c4/just-in-time-jit-compiler-in-C-Sharp/

There are 3 Types of JIT
1. Pre-JIT:- Pre-JIT complies complete source code into native code in a single compilation cycle. This is done at the time of deployment of the application.
2. Econo-JIT:- Econo-JIT complies only those methods that are called at runtime. However, these complied methods are removed when they are not required.
3. Normal-JIT:- Normal-JIT complies only those methods that are called at runtime. These methods are complied the first time they are called, and then they are stored in cache. When the same methods are called again, the complied code from cache is used for execution.