found culprit

Author: dadhi

src/FastExpressionCompiler/FastExpressionCompiler.cs

@@ -240,7 +240,7 @@ public static Func<T1, T2, R> CompileFast<T1, T2, R>(this Expression<Func<T1, T2
 #else
                 lambdaExpr.Parameters,
 #endif
-                new[] { typeof(ArrayClosure), typeof(T1), typeof(T2) },
+                new[] { typeof(ArrayClosure), typeof(T1), typeof(T2) }, // todo: @perf rent and return the array of types to pool
                 typeof(R), flags) ?? (ifFastFailedReturnNull ? null : lambdaExpr.CompileSys());
 
         /// <summary>Compiles lambda expression to delegate. Use ifFastFailedReturnNull parameter to Not fallback to Expression.Compile, useful for testing.</summary>
@@ -514,6 +514,9 @@ internal static object TryCompileBoundToFirstClosureParam(Type delegateType, Exp
                 closure = new DebugArrayClosure(constantsAndNestedLambdas, debugExpr);
             }
 
+            // todo: @slow this is what System.Compiles does and which makes the compilation significally slower 10x, but the invocation become faster by a single branch instruction
+            // var method = new DynamicMethod(string.Empty, returnType, closurePlusParamTypes, true);
+            // this is FEC way, significantly faster compilation, but +1 branch instruction in the invocation
             var method = new DynamicMethod(string.Empty, returnType, closurePlusParamTypes, typeof(ArrayClosure), true);
 
             // todo: @perf can we just count the Expressions in the TryCollect phase and use it as N * 4 or something?
@@ -536,6 +539,7 @@ internal static object TryCompileBoundToFirstClosureParam(Type delegateType, Exp
         private static readonly Type[] _closureAsASingleParamType = { typeof(ArrayClosure) };
         private static readonly Type[][] _closureTypePlusParamTypesPool = new Type[8][]; // todo: @perf @mem could we use this for other Type arrays?
 
+        // todo: @perf optimize
 #if LIGHT_EXPRESSION
         private static Type[] RentOrNewClosureTypeToParamTypes(IParameterProvider paramExprs)
         {

test/FastExpressionCompiler.Benchmarks/Issue468_Compile_vs_FastCompile.cs

@@ -56,9 +56,27 @@ .NET SDK 9.0.203
 | InvokeCompiled | 0.2685 ns | 0.0210 ns | 0.0186 ns |  1.00 |    0.09 |    2 |         - |          NA |
 | JustFunc       | 0.1711 ns | 0.0310 ns | 0.0305 ns |  0.64 |    0.12 |    1 |         - |          NA |
 
+## HERE IS THE REASON: 
+
+FEC creates the DynamicMethod with `owner` param, but System compile uses the different overload without owner and internally with `transparentMethod: true`.
+Using this latter (System) overload drastically slows down the compilation but removes the additional branch instruction in the invocation, making a super simple delegates faster.
+But for the delegates doing actual/more work, having additional branch instruction is neglegible and usually does not show in the invocation performance.  
+
+2x slowleness: `var method = new DynamicMethod(string.Empty, returnType, closurePlusParamTypes, typeof(ArrayClosure), true);`
+                                                                                               ^^^^^^^^^^^^^^^^^^^^
+parity:        `var method = new DynamicMethod(string.Empty, returnType, closurePlusParamTypes, true);`
+
+
+Job=.NET 8.0  Runtime=.NET 8.0
+
+| Method             | Mean      | Error     | StdDev    | Ratio | RatioSD | Rank | BranchInstructions/Op | Allocated | Alloc Ratio |
+|------------------- |----------:|----------:|----------:|------:|--------:|-----:|----------------------:|----------:|------------:|
+| InvokeCompiled     | 0.5075 ns | 0.0153 ns | 0.0143 ns |  1.00 |    0.04 |    1 |                     1 |         - |          NA |
+| InvokeCompiledFast | 0.5814 ns | 0.0433 ns | 0.0699 ns |  1.15 |    0.14 |    1 |                     1 |         - |          NA |
+
 */
 [MemoryDiagnoser, RankColumn]
-// [HardwareCounters(HardwareCounter.CacheMisses, HardwareCounter.BranchMispredictions, HardwareCounter.BranchInstructions)]
+[HardwareCounters(HardwareCounter.BranchInstructions)]
 // [SimpleJob(RuntimeMoniker.Net90)]
 [SimpleJob(RuntimeMoniker.Net80)]
 public class Issue468_InvokeCompiled_vs_InvokeCompiledFast
@@ -79,13 +97,13 @@ public bool InvokeCompiled()
         return _compiled();
     }
 
-    // [Benchmark]
+    [Benchmark]
     public bool InvokeCompiledFast()
     {
         return _compiledFast();
     }
 
-    [Benchmark]
+    // [Benchmark]
     public bool JustFunc()
     {
         return _justFunc();