jit

With a 150 *.dll ASP.NET website that's precompiled (updatable), what are some possible causes for a ' % Time in JIT ' that is often quite high (> 60%) and fluctuating long after the application has warmed-up (all functionality accessed) and without app restarts or file changes that might generate new assemblies? One would expect that the machine code generated for all assemblies would be re-used for the duration of that app-domain. Is there a finite size to the volume of machine-code that's cached? Under what scenarios would the same assembly need to be re-JIT'd in the same app domain? Or is

I'm trying to understand which events lead to class loads on a very detailed basis and during my testing encountered one behaviour I do not understand in this very basic sample: public class ClinitTest { public static Integer num; public static Long NUMTEST; static { NUMTEST = new Long(15);; num = (int) (NUMTEST * 5); System.out.println(num); } public static void main(String[] args) { System.out.println( "The number is " + num); } } When running java.lang.Long gets loaded while executing the <clinit> . Well, it gets loaded earlier by bootstrap classloader but the AppClassloader is called at

Ok this is merely curiosity, serves no real world help. I know that with expression trees you can generate MSIL on the fly just like the regular C# compiler does. Since compiler can decide optimizations, I'm tempted to ask what is the case with IL generated during Expression.Compile() . Basically two questions: Since at compile time the compiler can produce different (may be slightly) IL in debug mode and release mode , is there ever a difference in the IL generated by compiling an expression when built in debug mode and release mode? Also JIT which convert IL to native code at run time should

I would write this question directly to Jeffrey Richter, but last time he didn't answer me :) so I will try to get an answer with your help here, guys :) In the book "CLR via C#", 3rd edition, on p.108, Jeffrey writes: void M3() { Employee e; e = new Manager(); year = e.GetYearsEmployed(); ... } The next line of code in M3 calls Employee’s nonvirtual instance GetYearsEmployed method. When calling a nonvirtual instance method, the JIT compiler locates the type object that corresponds to the type of the variable being used to make the call. In this case, the variable e is defined as an Employee.

I was wondering if there's any way to change the behavior of the .NET JIT compiler, by specifying a preference for more in-depth optimizations. Failing that, it would be nice if it could do some kind of profile-guided optimization, if it doesn't already. This is set when you compile your assembly. There are two types of optimizations: IL optimization JIT Native Code quality. The default setting is this /optimize- /debug- This means unoptimized IL, and optimized native code. /optimize /debug(+/full/pdbonly) This means unoptimized IL, and unoptimized native code (best debug settings). Finally,