Is the IL generated by expression trees optimized?

Question

Well, this is just curiosity, does not help real help.

I know that with expression trees you can generate MSIL "on the fly", as a regular C # compiler does. Since the compiler can solve the optimization, I am tempted to ask what happens to the IL generated during Expression.Compile() . Basically two questions:

• Since at compile time the compiler can create different (maybe a little) ILs in debug mode and release mode, is there ever a difference in IL generated by compiling an expression when building in debug mode and release mode?

• Also, the JIT, which converts IL to native code at runtime, must be significantly different in both debug mode and release mode. Does this also apply to compiled expressions? Or IL from expression trees not related at all?

My understanding may be wrong, correct me in the case.

Note. . I consider cases when the debugger is disabled. I am asking about the default configuration setting that comes with "debug" and "release" in visual studio.

Answer 1

Since at compile time the compiler can create different (maybe a little) ILs in debug mode and release mode, is there ever a difference in IL generated by compiling an expression when building in debug mode and release mode?

This actually has a very simple answer: no. Given two identical LINQ / DLR expression trees, there will be no difference in the generated IL if it is compiled by an application running in release mode and the other in debug mode. I am not sure how this will be implemented anyway; I don’t know what a reliable way for the code inside System.Core to know that your project is building a debug build or release.

However, this answer may be misleading. The IL emitted by the expression compiler may not differ between debug and release assemblies, but in cases where expression trees are emitted by the C # compiler, it is possible that the structure of the expression trees themselves may differ between debug and release modes. I am quite familiar with the internal components of LINQ / DLR, but not so much with the C # compiler, so I can only say that in these cases there may be a difference (and it cannot be).

Also, the JIT, which converts IL to native code at runtime, must be significantly different in both debug mode and release mode. Does this also apply to compiled expressions? Or IL from expression trees not related at all?

The machine code that the JIT compiler spits out will not necessarily be very different for a pre-optimized IL versus an unoptimized IL. The results may be the same, especially if the only differences are a few additional time values. I suspect that the two will differ in their broader and more complex methods, since there is usually an upper limit to the time / effort that JIT will spend on optimizing this method. But it looks like you're more interested in how the quality of compiled LINQ / DLR expression trees compares, say, with C # code compiled in debug or release mode.

I can say that LINQ / DLR LambdaCompiler performs very few optimizations - less than the C # compiler in Release mode; Debug mode may be closer, but I would put my money on the C # compiler a bit more aggressive. LambdaCompiler usually does not try to reduce the use of temporary locales, and operations such as conditional expressions, comparisons, and type conversions will usually use more intermediate local networks than you might expect. In fact, I can only think of three optimizations that it performs:

• Nested lambdas will, when possible, be inlaid (and "when possible", usually "most of the time"). Actually it can help. Please note: this only works when you are Invoke a LambdaExpression ; it does not apply if you call the compiled delegate inside your expression.

• Conversions of unnecessary / redundant types are omitted, at least in some cases.

• If the value of a TypeBinaryExpression (ie [value] is [Type] ) is known at compile time, this value can be included as a constant.

In addition to # 3, the expression compiler does not use expression-based optimization; that is, he will not analyze the expression tree looking for optimization possibilities. Other optimizations in the list occur with little or no context for other expressions in the tree.

As a general rule, you should assume that the IL resulting from the compiled LINQ / DLR expression is significantly less optimized than the IL created by the C # compiler. However, the resulting IL-code has the right to optimize JIT , so it is difficult to evaluate the impact of real-world performance if you are not really trying to measure it using equivalent code.

One of the things to keep in mind when compiling code with expression trees is that you are actually a compiler ¹ . LINQ / DLR trees are designed to emit some other compiler infrastructure, for example, for various DLR implementations. Therefore, you will have to handle expression-level optimization. If you are a sloppy compiler and emit a bunch of unnecessary or redundant code, the generated IL will be larger and less likely to be aggressively optimized by the JIT compiler. Therefore, be careful about the expressions you are building, but not too worried. If you need a highly optimized IL, you just have to emit it yourself. But in most cases, LINQ / DLR trees work fine.

---

<sub> ¹ If you have ever wondered why LINQ / DLR expressions are so pedantic regarding the need for exact type matching, this is because they are intended to be used as a compiler target for several languages, each of which may have different rules in regarding method binding, implicit and explicit type conversion, etc. Therefore, when building LINQ / DLR trees manually, you must do the work that the compiler usually does behind the scenes, for example, automatically inserting code for implicit conversions.

Answer 2

Squared int .

I'm not sure if this is a lot, but I came up with the following example:

 // make delegate and find length of IL: Func<int, int> f = x => x * x; Console.WriteLine(f.Method.GetMethodBody().GetILAsByteArray().Length); // make expression tree Expression<Func<int, int>> e = x => x * x; // one approach to finding IL length var methInf = e.Compile().Method; var owner = (System.Reflection.Emit.DynamicMethod)methInf.GetType().GetField("m_owner", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance).GetValue(methInf); Console.WriteLine(owner.GetILGenerator().ILOffset); // another approach to finding IL length var an = new System.Reflection.AssemblyName("myTest"); var assem = AppDomain.CurrentDomain.DefineDynamicAssembly(an, System.Reflection.Emit.AssemblyBuilderAccess.RunAndSave); var module = assem.DefineDynamicModule("myTest"); var type = module.DefineType("myClass"); var methBuilder = type.DefineMethod("myMeth", System.Reflection.MethodAttributes.Static); e.CompileToMethod(methBuilder); Console.WriteLine(methBuilder.GetILGenerator().ILOffset); 

Results:

In the Debug configuration, the length of the compile-time method is 8, and the length of the emitted method is 4.

In the Release configuration, the length of the compilation method is 4, and the length of the emitted method is also 4.

The compile-time method considered by IL DASM in debug mode:

 .method private hidebysig static int32 '<Main>b__0'(int32 x) cil managed { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) // Code size 8 (0x8) .maxstack 2 .locals init ([0] int32 CS$1$0000) IL_0000: ldarg.0 IL_0001: ldarg.0 IL_0002: mul IL_0003: stloc.0 IL_0004: br.s IL_0006 IL_0006: ldloc.0 IL_0007: ret } 

and Release:

 .method private hidebysig static int32 '<Main>b__0'(int32 x) cil managed { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) // Code size 4 (0x4) .maxstack 8 IL_0000: ldarg.0 IL_0001: ldarg.0 IL_0002: mul IL_0003: ret } 

Disclaimer: I'm not sure if something can be done (this is a long “comment”), but is Compile() always possible with “optimizations”?

Answer 3

Regarding IL

As pointed out in other answers, detecting debug / release at runtime is not really a “thing” because it is a compile-time solution that is controlled by the project configuration and not what is actually detected in the inline assembly. The runtime may reflect the AssemblyConfiguration attribute on the assembly, checking its Configuration , but that would be an inaccurate solution for something so fundamental to .Net - because this line could be literally any.

Furthermore, this attribute cannot be guaranteed to exist in the assembly, and since we can mix and match release / debug assemblies in the same process, it is almost impossible to say "this is a debug / release process."

Finally, as others have pointed out, DEBUG != UNOPTIMISED - the concept of a "debugged" assembly is more about conventions than anything else (reflected in the default compilation settings for the .Net project) - conventions that control the details in the PDB (rather than the existence one, by the way) and is the code optimized. Thus, it is possible to have an optimized debug build, as well as an unspecified release build, and even an optimized release build with full PDB information, which can be debugged just like a standard debug build.

In addition, the expression tree compiler translates mainly directly expressions inside the lambda to IL (with the exception of some nuances, such as excess descending from the derived reference type to the base reference type), and therefore the generated IL is optimized as the expression tree that you wrote . Therefore, it is unlikely that IL is different between a Debug / Release assembly, because there is virtually no such thing as a debug / release process, only an assembly and, as mentioned above, there is no reliable way to detect this.

But what about JIT?

However, when it comes to JIT translating IL to assembler, I think it's worth noting that JIT (although not sure about the .Net kernel) does differently if the process starts with a debugger attached versus when it starts without it . Try starting release builds using F5 from VS and compare the debug behavior and attach it to it after it starts.

Now these differences may not be mainly due to optimizations (most of the difference probably ensures that the PDB information is supported in the generated machine code), but you will see many more “methods optimized” messages in the stack trace when connected to the release process than you, if at all, when you start it with a debugger connected from the very beginning.

My point is that if the presence of a debugger can affect the behavior of JITing for a statically constructed IL, then it probably affects its behavior when JITing dynamically built an IL, for example, related delegates or, in this case, expression trees . However, how different I am from this, I am not sure what we can say.